// $ANTLR 3.4 C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g 2012-10-31 15:49:06

package PL.prac7;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked"})
public class YACCParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "ACORCHETE", "ALLAVE", "ALMOHADILLA", "AND", "APARENTESIS", "ASTERISCO", "BARRA", "BLANCO", "BREAK", "CADENA", "CARACTER", "CCORCHETE", "CHAR", "CLLAVE", "COMA", "COMENTARIO", "COMILLA", "COMILLAS", "CPARENTESIS", "DEFINE", "DIGITO", "DOLAR", "DOLARDOLAR", "DOSPUNTOS", "DOUBLE", "ELSE", "ESPACIO", "EXTERN", "FINDEFINICIONES", "FLOAT", "FOR", "IDENT", "IF", "IGUAL", "INCLUDE", "INIDEFINICIONES", "INT", "INTERROGANTE", "LETRA", "MAIN", "MAS", "MAYOR", "MENOR", "MENOS", "NOT", "NUEVA_LINEA", "NUMERO", "OR", "ORYACC", "PORCENTAJE", "PUNTO", "RETURN", "SEPARADOR", "STRUCT", "TIPO", "TYPEDEF", "VAR", "VOID", "WHILE", "ZONAREGLA", "TOKEN", "TYPE"
    };

    public static final int EOF=-1;
    public static final int ACORCHETE=4;
    public static final int ALLAVE=5;
    public static final int ALMOHADILLA=6;
    public static final int AND=7;
    public static final int APARENTESIS=8;
    public static final int ASTERISCO=9;
    public static final int BARRA=10;
    public static final int BLANCO=11;
    public static final int BREAK=12;
    public static final int CADENA=13;
    public static final int CARACTER=14;
    public static final int CCORCHETE=15;
    public static final int CHAR=16;
    public static final int CLLAVE=17;
    public static final int COMA=18;
    public static final int COMENTARIO=19;
    public static final int COMILLA=20;
    public static final int COMILLAS=21;
    public static final int CPARENTESIS=22;
    public static final int DEFINE=23;
    public static final int DIGITO=24;
    public static final int DOLAR=25;
    public static final int DOLARDOLAR=26;
    public static final int DOSPUNTOS=27;
    public static final int DOUBLE=28;
    public static final int ELSE=29;
    public static final int ESPACIO=30;
    public static final int EXTERN=31;
    public static final int FINDEFINICIONES=32;
    public static final int FLOAT=33;
    public static final int FOR=34;
    public static final int IDENT=35;
    public static final int IF=36;
    public static final int IGUAL=37;
    public static final int INCLUDE=38;
    public static final int INIDEFINICIONES=39;
    public static final int INT=40;
    public static final int INTERROGANTE=41;
    public static final int LETRA=42;
    public static final int MAIN=43;
    public static final int MAS=44;
    public static final int MAYOR=45;
    public static final int MENOR=46;
    public static final int MENOS=47;
    public static final int NOT=48;
    public static final int NUEVA_LINEA=49;
    public static final int NUMERO=50;
    public static final int OR=51;
    public static final int ORYACC=52;
    public static final int PORCENTAJE=53;
    public static final int PUNTO=54;
    public static final int RETURN=55;
    public static final int SEPARADOR=56;
    public static final int STRUCT=57;
    public static final int TIPO=58;
    public static final int TYPEDEF=59;
    public static final int VAR=60;
    public static final int VOID=61;
    public static final int WHILE=62;
    public static final int ZONAREGLA=63;
    public static final int TOKEN=64;
    public static final int TYPE=65;

    // delegates
    public Parser[] getDelegates() {
        return new Parser[] {};
    }

    // delegators


    public YACCParser(TokenStream input) {
        this(input, new RecognizerSharedState());
    }
    public YACCParser(TokenStream input, RecognizerSharedState state) {
        super(input, state);
    }

    public String[] getTokenNames() { return YACCParser.tokenNames; }
    public String getGrammarFileName() { return "C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g"; }



    // $ANTLR start "entrada"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:16:1: entrada : definiciones expresiones ( partec )? EOF ;
    public final void entrada() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:16:8: ( definiciones expresiones ( partec )? EOF )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:16:10: definiciones expresiones ( partec )? EOF
            {
            pushFollow(FOLLOW_definiciones_in_entrada47);
            definiciones();

            state._fsp--;


            pushFollow(FOLLOW_expresiones_in_entrada49);
            expresiones();

            state._fsp--;


            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:16:35: ( partec )?
            int alt1=2;
            int LA1_0 = input.LA(1);

            if ( (LA1_0==ALMOHADILLA||LA1_0==EXTERN||LA1_0==IDENT||LA1_0==MAIN||(LA1_0 >= TIPO && LA1_0 <= TYPEDEF)||LA1_0==VOID) ) {
                alt1=1;
            }
            switch (alt1) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:16:35: partec
                    {
                    pushFollow(FOLLOW_partec_in_entrada51);
                    partec();

                    state._fsp--;


                    }
                    break;

            }


            match(input,EOF,FOLLOW_EOF_in_entrada54); 

            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "entrada"



    // $ANTLR start "identificador"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:18:1: identificador : IDENT ( ACORCHETE ( operacion )? CCORCHETE )? ;
    public final void identificador() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:18:14: ( IDENT ( ACORCHETE ( operacion )? CCORCHETE )? )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:18:16: IDENT ( ACORCHETE ( operacion )? CCORCHETE )?
            {
            match(input,IDENT,FOLLOW_IDENT_in_identificador61); 

            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:18:21: ( ACORCHETE ( operacion )? CCORCHETE )?
            int alt3=2;
            int LA3_0 = input.LA(1);

            if ( (LA3_0==ACORCHETE) ) {
                alt3=1;
            }
            switch (alt3) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:18:22: ACORCHETE ( operacion )? CCORCHETE
                    {
                    match(input,ACORCHETE,FOLLOW_ACORCHETE_in_identificador63); 

                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:18:32: ( operacion )?
                    int alt2=2;
                    int LA2_0 = input.LA(1);

                    if ( (LA2_0==ASTERISCO||(LA2_0 >= CADENA && LA2_0 <= CARACTER)||LA2_0==DOLARDOLAR||LA2_0==IDENT||LA2_0==MENOS||LA2_0==NUMERO||LA2_0==VAR) ) {
                        alt2=1;
                    }
                    switch (alt2) {
                        case 1 :
                            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:18:33: operacion
                            {
                            pushFollow(FOLLOW_operacion_in_identificador66);
                            operacion();

                            state._fsp--;


                            }
                            break;

                    }


                    match(input,CCORCHETE,FOLLOW_CCORCHETE_in_identificador70); 

                    }
                    break;

            }


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "identificador"



    // $ANTLR start "struct"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:19:1: struct : ( ( ASTERISCO )? identificador | VAR | DOLARDOLAR | llamada_funcion ) ( PUNTO IDENT )? ;
    public final void struct() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:19:7: ( ( ( ASTERISCO )? identificador | VAR | DOLARDOLAR | llamada_funcion ) ( PUNTO IDENT )? )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:19:9: ( ( ASTERISCO )? identificador | VAR | DOLARDOLAR | llamada_funcion ) ( PUNTO IDENT )?
            {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:19:9: ( ( ASTERISCO )? identificador | VAR | DOLARDOLAR | llamada_funcion )
            int alt5=4;
            switch ( input.LA(1) ) {
            case ASTERISCO:
                {
                alt5=1;
                }
                break;
            case IDENT:
                {
                int LA5_2 = input.LA(2);

                if ( (LA5_2==APARENTESIS) ) {
                    alt5=4;
                }
                else if ( (LA5_2==ACORCHETE||LA5_2==AND||(LA5_2 >= ASTERISCO && LA5_2 <= BARRA)||LA5_2==CCORCHETE||LA5_2==COMA||LA5_2==CPARENTESIS||LA5_2==IGUAL||(LA5_2 >= MAS && LA5_2 <= MENOS)||LA5_2==OR||LA5_2==PUNTO||LA5_2==SEPARADOR) ) {
                    alt5=1;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 5, 2, input);

                    throw nvae;

                }
                }
                break;
            case VAR:
                {
                alt5=2;
                }
                break;
            case DOLARDOLAR:
                {
                alt5=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 5, 0, input);

                throw nvae;

            }

            switch (alt5) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:19:10: ( ASTERISCO )? identificador
                    {
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:19:10: ( ASTERISCO )?
                    int alt4=2;
                    int LA4_0 = input.LA(1);

                    if ( (LA4_0==ASTERISCO) ) {
                        alt4=1;
                    }
                    switch (alt4) {
                        case 1 :
                            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:19:10: ASTERISCO
                            {
                            match(input,ASTERISCO,FOLLOW_ASTERISCO_in_struct79); 

                            }
                            break;

                    }


                    pushFollow(FOLLOW_identificador_in_struct82);
                    identificador();

                    state._fsp--;


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:19:35: VAR
                    {
                    match(input,VAR,FOLLOW_VAR_in_struct84); 

                    }
                    break;
                case 3 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:19:39: DOLARDOLAR
                    {
                    match(input,DOLARDOLAR,FOLLOW_DOLARDOLAR_in_struct86); 

                    }
                    break;
                case 4 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:19:50: llamada_funcion
                    {
                    pushFollow(FOLLOW_llamada_funcion_in_struct88);
                    llamada_funcion();

                    state._fsp--;


                    }
                    break;

            }


            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:19:67: ( PUNTO IDENT )?
            int alt6=2;
            int LA6_0 = input.LA(1);

            if ( (LA6_0==PUNTO) ) {
                alt6=1;
            }
            switch (alt6) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:19:68: PUNTO IDENT
                    {
                    match(input,PUNTO,FOLLOW_PUNTO_in_struct92); 

                    match(input,IDENT,FOLLOW_IDENT_in_struct94); 

                    }
                    break;

            }


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "struct"



    // $ANTLR start "subsentencia"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:20:1: subsentencia : ( struct | NUMERO | CADENA | CARACTER ) ;
    public final void subsentencia() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:20:13: ( ( struct | NUMERO | CADENA | CARACTER ) )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:20:15: ( struct | NUMERO | CADENA | CARACTER )
            {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:20:15: ( struct | NUMERO | CADENA | CARACTER )
            int alt7=4;
            switch ( input.LA(1) ) {
            case ASTERISCO:
            case DOLARDOLAR:
            case IDENT:
            case VAR:
                {
                alt7=1;
                }
                break;
            case NUMERO:
                {
                alt7=2;
                }
                break;
            case CADENA:
                {
                alt7=3;
                }
                break;
            case CARACTER:
                {
                alt7=4;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 7, 0, input);

                throw nvae;

            }

            switch (alt7) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:20:16: struct
                    {
                    pushFollow(FOLLOW_struct_in_subsentencia103);
                    struct();

                    state._fsp--;


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:20:24: NUMERO
                    {
                    match(input,NUMERO,FOLLOW_NUMERO_in_subsentencia106); 

                    }
                    break;
                case 3 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:20:33: CADENA
                    {
                    match(input,CADENA,FOLLOW_CADENA_in_subsentencia110); 

                    }
                    break;
                case 4 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:20:42: CARACTER
                    {
                    match(input,CARACTER,FOLLOW_CARACTER_in_subsentencia114); 

                    }
                    break;

            }


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "subsentencia"



    // $ANTLR start "operacion"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:21:1: operacion : ( MENOS )? subsentencia ( ( MAS | MENOS | ASTERISCO | BARRA ) ( MENOS )? subsentencia )* ;
    public final void operacion() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:21:10: ( ( MENOS )? subsentencia ( ( MAS | MENOS | ASTERISCO | BARRA ) ( MENOS )? subsentencia )* )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:21:12: ( MENOS )? subsentencia ( ( MAS | MENOS | ASTERISCO | BARRA ) ( MENOS )? subsentencia )*
            {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:21:12: ( MENOS )?
            int alt8=2;
            int LA8_0 = input.LA(1);

            if ( (LA8_0==MENOS) ) {
                alt8=1;
            }
            switch (alt8) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:21:12: MENOS
                    {
                    match(input,MENOS,FOLLOW_MENOS_in_operacion121); 

                    }
                    break;

            }


            pushFollow(FOLLOW_subsentencia_in_operacion124);
            subsentencia();

            state._fsp--;


            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:21:32: ( ( MAS | MENOS | ASTERISCO | BARRA ) ( MENOS )? subsentencia )*
            loop10:
            do {
                int alt10=2;
                int LA10_0 = input.LA(1);

                if ( ((LA10_0 >= ASTERISCO && LA10_0 <= BARRA)||LA10_0==MAS||LA10_0==MENOS) ) {
                    alt10=1;
                }


                switch (alt10) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:21:33: ( MAS | MENOS | ASTERISCO | BARRA ) ( MENOS )? subsentencia
            	    {
            	    if ( (input.LA(1) >= ASTERISCO && input.LA(1) <= BARRA)||input.LA(1)==MAS||input.LA(1)==MENOS ) {
            	        input.consume();
            	        state.errorRecovery=false;
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:21:61: ( MENOS )?
            	    int alt9=2;
            	    int LA9_0 = input.LA(1);

            	    if ( (LA9_0==MENOS) ) {
            	        alt9=1;
            	    }
            	    switch (alt9) {
            	        case 1 :
            	            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:21:61: MENOS
            	            {
            	            match(input,MENOS,FOLLOW_MENOS_in_operacion137); 

            	            }
            	            break;

            	    }


            	    pushFollow(FOLLOW_subsentencia_in_operacion140);
            	    subsentencia();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop10;
                }
            } while (true);


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "operacion"



    // $ANTLR start "igualacion"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:22:1: igualacion : struct ( IGUAL operacion )* ;
    public final void igualacion() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:22:11: ( struct ( IGUAL operacion )* )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:22:13: struct ( IGUAL operacion )*
            {
            pushFollow(FOLLOW_struct_in_igualacion148);
            struct();

            state._fsp--;


            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:22:20: ( IGUAL operacion )*
            loop11:
            do {
                int alt11=2;
                int LA11_0 = input.LA(1);

                if ( (LA11_0==IGUAL) ) {
                    alt11=1;
                }


                switch (alt11) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:22:21: IGUAL operacion
            	    {
            	    match(input,IGUAL,FOLLOW_IGUAL_in_igualacion151); 

            	    pushFollow(FOLLOW_operacion_in_igualacion153);
            	    operacion();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop11;
                }
            } while (true);


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "igualacion"



    // $ANTLR start "sentencia"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:23:1: sentencia : igualacion ( COMA igualacion )* SEPARADOR ;
    public final void sentencia() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:23:10: ( igualacion ( COMA igualacion )* SEPARADOR )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:23:12: igualacion ( COMA igualacion )* SEPARADOR
            {
            pushFollow(FOLLOW_igualacion_in_sentencia161);
            igualacion();

            state._fsp--;


            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:23:23: ( COMA igualacion )*
            loop12:
            do {
                int alt12=2;
                int LA12_0 = input.LA(1);

                if ( (LA12_0==COMA) ) {
                    alt12=1;
                }


                switch (alt12) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:23:24: COMA igualacion
            	    {
            	    match(input,COMA,FOLLOW_COMA_in_sentencia164); 

            	    pushFollow(FOLLOW_igualacion_in_sentencia166);
            	    igualacion();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop12;
                }
            } while (true);


            match(input,SEPARADOR,FOLLOW_SEPARADOR_in_sentencia170); 

            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "sentencia"



    // $ANTLR start "definicion"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:24:1: definicion : ( TIPO | IDENT ) igualacion ( COMA igualacion )* SEPARADOR ;
    public final void definicion() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:24:11: ( ( TIPO | IDENT ) igualacion ( COMA igualacion )* SEPARADOR )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:24:13: ( TIPO | IDENT ) igualacion ( COMA igualacion )* SEPARADOR
            {
            if ( input.LA(1)==IDENT||input.LA(1)==TIPO ) {
                input.consume();
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            pushFollow(FOLLOW_igualacion_in_definicion182);
            igualacion();

            state._fsp--;


            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:24:37: ( COMA igualacion )*
            loop13:
            do {
                int alt13=2;
                int LA13_0 = input.LA(1);

                if ( (LA13_0==COMA) ) {
                    alt13=1;
                }


                switch (alt13) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:24:38: COMA igualacion
            	    {
            	    match(input,COMA,FOLLOW_COMA_in_definicion185); 

            	    pushFollow(FOLLOW_igualacion_in_definicion187);
            	    igualacion();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop13;
                }
            } while (true);


            match(input,SEPARADOR,FOLLOW_SEPARADOR_in_definicion191); 

            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "definicion"



    // $ANTLR start "definiciones"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:28:1: definiciones : INIDEFINICIONES declaracionc FINDEFINICIONES ( definiciontoken )* ;
    public final void definiciones() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:28:13: ( INIDEFINICIONES declaracionc FINDEFINICIONES ( definiciontoken )* )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:28:15: INIDEFINICIONES declaracionc FINDEFINICIONES ( definiciontoken )*
            {
            match(input,INIDEFINICIONES,FOLLOW_INIDEFINICIONES_in_definiciones200); 

            pushFollow(FOLLOW_declaracionc_in_definiciones202);
            declaracionc();

            state._fsp--;


            match(input,FINDEFINICIONES,FOLLOW_FINDEFINICIONES_in_definiciones204); 

            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:28:60: ( definiciontoken )*
            loop14:
            do {
                int alt14=2;
                int LA14_0 = input.LA(1);

                if ( (LA14_0==PORCENTAJE) ) {
                    alt14=1;
                }


                switch (alt14) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:28:61: definiciontoken
            	    {
            	    pushFollow(FOLLOW_definiciontoken_in_definiciones207);
            	    definiciontoken();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop14;
                }
            } while (true);


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "definiciones"



    // $ANTLR start "declaracionc"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:29:1: declaracionc : ( define | include | typedefs | declarfunc | array )+ ;
    public final void declaracionc() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:29:13: ( ( define | include | typedefs | declarfunc | array )+ )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:29:15: ( define | include | typedefs | declarfunc | array )+
            {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:29:15: ( define | include | typedefs | declarfunc | array )+
            int cnt15=0;
            loop15:
            do {
                int alt15=6;
                alt15 = dfa15.predict(input);
                switch (alt15) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:29:16: define
            	    {
            	    pushFollow(FOLLOW_define_in_declaracionc217);
            	    define();

            	    state._fsp--;


            	    }
            	    break;
            	case 2 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:29:24: include
            	    {
            	    pushFollow(FOLLOW_include_in_declaracionc220);
            	    include();

            	    state._fsp--;


            	    }
            	    break;
            	case 3 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:29:32: typedefs
            	    {
            	    pushFollow(FOLLOW_typedefs_in_declaracionc222);
            	    typedefs();

            	    state._fsp--;


            	    }
            	    break;
            	case 4 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:29:41: declarfunc
            	    {
            	    pushFollow(FOLLOW_declarfunc_in_declaracionc224);
            	    declarfunc();

            	    state._fsp--;


            	    }
            	    break;
            	case 5 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:29:52: array
            	    {
            	    pushFollow(FOLLOW_array_in_declaracionc226);
            	    array();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    if ( cnt15 >= 1 ) break loop15;
                        EarlyExitException eee =
                            new EarlyExitException(15, input);
                        throw eee;
                }
                cnt15++;
            } while (true);


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "declaracionc"



    // $ANTLR start "array"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:30:1: array : ( IDENT | TIPO ) IDENT ACORCHETE NUMERO CCORCHETE SEPARADOR ;
    public final void array() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:30:6: ( ( IDENT | TIPO ) IDENT ACORCHETE NUMERO CCORCHETE SEPARADOR )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:30:8: ( IDENT | TIPO ) IDENT ACORCHETE NUMERO CCORCHETE SEPARADOR
            {
            if ( input.LA(1)==IDENT||input.LA(1)==TIPO ) {
                input.consume();
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            match(input,IDENT,FOLLOW_IDENT_in_array240); 

            match(input,ACORCHETE,FOLLOW_ACORCHETE_in_array242); 

            match(input,NUMERO,FOLLOW_NUMERO_in_array244); 

            match(input,CCORCHETE,FOLLOW_CCORCHETE_in_array246); 

            match(input,SEPARADOR,FOLLOW_SEPARADOR_in_array248); 

            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "array"



    // $ANTLR start "declarfunc"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:31:1: declarfunc : ( TIPO | IDENT ) llamada_funcion ( COMA llamada_funcion )* SEPARADOR ;
    public final void declarfunc() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:31:11: ( ( TIPO | IDENT ) llamada_funcion ( COMA llamada_funcion )* SEPARADOR )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:31:13: ( TIPO | IDENT ) llamada_funcion ( COMA llamada_funcion )* SEPARADOR
            {
            if ( input.LA(1)==IDENT||input.LA(1)==TIPO ) {
                input.consume();
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            pushFollow(FOLLOW_llamada_funcion_in_declarfunc260);
            llamada_funcion();

            state._fsp--;


            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:31:42: ( COMA llamada_funcion )*
            loop16:
            do {
                int alt16=2;
                int LA16_0 = input.LA(1);

                if ( (LA16_0==COMA) ) {
                    alt16=1;
                }


                switch (alt16) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:31:43: COMA llamada_funcion
            	    {
            	    match(input,COMA,FOLLOW_COMA_in_declarfunc263); 

            	    pushFollow(FOLLOW_llamada_funcion_in_declarfunc265);
            	    llamada_funcion();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop16;
                }
            } while (true);


            match(input,SEPARADOR,FOLLOW_SEPARADOR_in_declarfunc269); 

            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "declarfunc"



    // $ANTLR start "typedefs"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:32:1: typedefs : TYPEDEF STRUCT IDENT ALLAVE ( varindefs )+ CLLAVE IDENT SEPARADOR ;
    public final void typedefs() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:32:9: ( TYPEDEF STRUCT IDENT ALLAVE ( varindefs )+ CLLAVE IDENT SEPARADOR )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:32:11: TYPEDEF STRUCT IDENT ALLAVE ( varindefs )+ CLLAVE IDENT SEPARADOR
            {
            match(input,TYPEDEF,FOLLOW_TYPEDEF_in_typedefs275); 

            match(input,STRUCT,FOLLOW_STRUCT_in_typedefs277); 

            match(input,IDENT,FOLLOW_IDENT_in_typedefs279); 

            match(input,ALLAVE,FOLLOW_ALLAVE_in_typedefs281); 

            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:32:39: ( varindefs )+
            int cnt17=0;
            loop17:
            do {
                int alt17=2;
                int LA17_0 = input.LA(1);

                if ( (LA17_0==IDENT||LA17_0==TIPO) ) {
                    alt17=1;
                }


                switch (alt17) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:32:40: varindefs
            	    {
            	    pushFollow(FOLLOW_varindefs_in_typedefs284);
            	    varindefs();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    if ( cnt17 >= 1 ) break loop17;
                        EarlyExitException eee =
                            new EarlyExitException(17, input);
                        throw eee;
                }
                cnt17++;
            } while (true);


            match(input,CLLAVE,FOLLOW_CLLAVE_in_typedefs288); 

            match(input,IDENT,FOLLOW_IDENT_in_typedefs290); 

            match(input,SEPARADOR,FOLLOW_SEPARADOR_in_typedefs292); 

            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "typedefs"



    // $ANTLR start "varindefs"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:33:1: varindefs : ( TIPO | IDENT ) IDENT ( COMA IDENT )* SEPARADOR ;
    public final void varindefs() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:33:10: ( ( TIPO | IDENT ) IDENT ( COMA IDENT )* SEPARADOR )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:33:12: ( TIPO | IDENT ) IDENT ( COMA IDENT )* SEPARADOR
            {
            if ( input.LA(1)==IDENT||input.LA(1)==TIPO ) {
                input.consume();
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            match(input,IDENT,FOLLOW_IDENT_in_varindefs304); 

            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:33:31: ( COMA IDENT )*
            loop18:
            do {
                int alt18=2;
                int LA18_0 = input.LA(1);

                if ( (LA18_0==COMA) ) {
                    alt18=1;
                }


                switch (alt18) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:33:32: COMA IDENT
            	    {
            	    match(input,COMA,FOLLOW_COMA_in_varindefs307); 

            	    match(input,IDENT,FOLLOW_IDENT_in_varindefs309); 

            	    }
            	    break;

            	default :
            	    break loop18;
                }
            } while (true);


            match(input,SEPARADOR,FOLLOW_SEPARADOR_in_varindefs313); 

            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "varindefs"



    // $ANTLR start "definiciontoken"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:34:1: definiciontoken : PORCENTAJE IDENT ( IDENT | ( CARACTER )+ | conjunto | ( MENOR IDENT MAYOR ( IDENT )+ ) ) ;
    public final void definiciontoken() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:34:16: ( PORCENTAJE IDENT ( IDENT | ( CARACTER )+ | conjunto | ( MENOR IDENT MAYOR ( IDENT )+ ) ) )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:34:18: PORCENTAJE IDENT ( IDENT | ( CARACTER )+ | conjunto | ( MENOR IDENT MAYOR ( IDENT )+ ) )
            {
            match(input,PORCENTAJE,FOLLOW_PORCENTAJE_in_definiciontoken319); 

            match(input,IDENT,FOLLOW_IDENT_in_definiciontoken321); 

            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:34:35: ( IDENT | ( CARACTER )+ | conjunto | ( MENOR IDENT MAYOR ( IDENT )+ ) )
            int alt21=4;
            switch ( input.LA(1) ) {
            case IDENT:
                {
                alt21=1;
                }
                break;
            case CARACTER:
                {
                alt21=2;
                }
                break;
            case ALLAVE:
                {
                alt21=3;
                }
                break;
            case MENOR:
                {
                alt21=4;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 21, 0, input);

                throw nvae;

            }

            switch (alt21) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:34:36: IDENT
                    {
                    match(input,IDENT,FOLLOW_IDENT_in_definiciontoken324); 

                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:34:42: ( CARACTER )+
                    {
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:34:42: ( CARACTER )+
                    int cnt19=0;
                    loop19:
                    do {
                        int alt19=2;
                        int LA19_0 = input.LA(1);

                        if ( (LA19_0==CARACTER) ) {
                            alt19=1;
                        }


                        switch (alt19) {
                    	case 1 :
                    	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:34:43: CARACTER
                    	    {
                    	    match(input,CARACTER,FOLLOW_CARACTER_in_definiciontoken327); 

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt19 >= 1 ) break loop19;
                                EarlyExitException eee =
                                    new EarlyExitException(19, input);
                                throw eee;
                        }
                        cnt19++;
                    } while (true);


                    }
                    break;
                case 3 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:34:54: conjunto
                    {
                    pushFollow(FOLLOW_conjunto_in_definiciontoken331);
                    conjunto();

                    state._fsp--;


                    }
                    break;
                case 4 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:34:63: ( MENOR IDENT MAYOR ( IDENT )+ )
                    {
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:34:63: ( MENOR IDENT MAYOR ( IDENT )+ )
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:34:64: MENOR IDENT MAYOR ( IDENT )+
                    {
                    match(input,MENOR,FOLLOW_MENOR_in_definiciontoken334); 

                    match(input,IDENT,FOLLOW_IDENT_in_definiciontoken336); 

                    match(input,MAYOR,FOLLOW_MAYOR_in_definiciontoken338); 

                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:34:82: ( IDENT )+
                    int cnt20=0;
                    loop20:
                    do {
                        int alt20=2;
                        int LA20_0 = input.LA(1);

                        if ( (LA20_0==IDENT) ) {
                            alt20=1;
                        }


                        switch (alt20) {
                    	case 1 :
                    	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:34:82: IDENT
                    	    {
                    	    match(input,IDENT,FOLLOW_IDENT_in_definiciontoken340); 

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt20 >= 1 ) break loop20;
                                EarlyExitException eee =
                                    new EarlyExitException(20, input);
                                throw eee;
                        }
                        cnt20++;
                    } while (true);


                    }


                    }
                    break;

            }


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "definiciontoken"



    // $ANTLR start "typetoken"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:35:1: typetoken : PORCENTAJE ( TYPE | TOKEN ) MENOR IDENT MAYOR ( IDENT )+ ;
    public final void typetoken() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:35:10: ( PORCENTAJE ( TYPE | TOKEN ) MENOR IDENT MAYOR ( IDENT )+ )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:35:12: PORCENTAJE ( TYPE | TOKEN ) MENOR IDENT MAYOR ( IDENT )+
            {
            match(input,PORCENTAJE,FOLLOW_PORCENTAJE_in_typetoken349); 

            if ( (input.LA(1) >= TOKEN && input.LA(1) <= TYPE) ) {
                input.consume();
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            match(input,MENOR,FOLLOW_MENOR_in_typetoken357); 

            match(input,IDENT,FOLLOW_IDENT_in_typetoken359); 

            match(input,MAYOR,FOLLOW_MAYOR_in_typetoken361); 

            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:35:54: ( IDENT )+
            int cnt22=0;
            loop22:
            do {
                int alt22=2;
                int LA22_0 = input.LA(1);

                if ( (LA22_0==IDENT) ) {
                    alt22=1;
                }


                switch (alt22) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:35:54: IDENT
            	    {
            	    match(input,IDENT,FOLLOW_IDENT_in_typetoken363); 

            	    }
            	    break;

            	default :
            	    if ( cnt22 >= 1 ) break loop22;
                        EarlyExitException eee =
                            new EarlyExitException(22, input);
                        throw eee;
                }
                cnt22++;
            } while (true);


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "typetoken"



    // $ANTLR start "conjunto"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:36:1: conjunto : ALLAVE ( varindefs )+ CLLAVE ;
    public final void conjunto() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:36:9: ( ALLAVE ( varindefs )+ CLLAVE )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:36:11: ALLAVE ( varindefs )+ CLLAVE
            {
            match(input,ALLAVE,FOLLOW_ALLAVE_in_conjunto370); 

            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:36:18: ( varindefs )+
            int cnt23=0;
            loop23:
            do {
                int alt23=2;
                int LA23_0 = input.LA(1);

                if ( (LA23_0==IDENT||LA23_0==TIPO) ) {
                    alt23=1;
                }


                switch (alt23) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:36:19: varindefs
            	    {
            	    pushFollow(FOLLOW_varindefs_in_conjunto373);
            	    varindefs();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    if ( cnt23 >= 1 ) break loop23;
                        EarlyExitException eee =
                            new EarlyExitException(23, input);
                        throw eee;
                }
                cnt23++;
            } while (true);


            match(input,CLLAVE,FOLLOW_CLLAVE_in_conjunto377); 

            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "conjunto"



    // $ANTLR start "define"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:37:1: define : ALMOHADILLA DEFINE IDENT ( TIPO | NUMERO ) ;
    public final void define() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:37:7: ( ALMOHADILLA DEFINE IDENT ( TIPO | NUMERO ) )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:37:9: ALMOHADILLA DEFINE IDENT ( TIPO | NUMERO )
            {
            match(input,ALMOHADILLA,FOLLOW_ALMOHADILLA_in_define383); 

            match(input,DEFINE,FOLLOW_DEFINE_in_define385); 

            match(input,IDENT,FOLLOW_IDENT_in_define387); 

            if ( input.LA(1)==NUMERO||input.LA(1)==TIPO ) {
                input.consume();
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "define"



    // $ANTLR start "include"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:38:1: include : ALMOHADILLA INCLUDE MENOR IDENT PUNTO IDENT MAYOR ;
    public final void include() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:38:8: ( ALMOHADILLA INCLUDE MENOR IDENT PUNTO IDENT MAYOR )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:38:10: ALMOHADILLA INCLUDE MENOR IDENT PUNTO IDENT MAYOR
            {
            match(input,ALMOHADILLA,FOLLOW_ALMOHADILLA_in_include399); 

            match(input,INCLUDE,FOLLOW_INCLUDE_in_include401); 

            match(input,MENOR,FOLLOW_MENOR_in_include403); 

            match(input,IDENT,FOLLOW_IDENT_in_include405); 

            match(input,PUNTO,FOLLOW_PUNTO_in_include407); 

            match(input,IDENT,FOLLOW_IDENT_in_include409); 

            match(input,MAYOR,FOLLOW_MAYOR_in_include411); 

            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "include"



    // $ANTLR start "expresiones"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:41:1: expresiones : ZONAREGLA ( reglas )* ZONAREGLA ;
    public final void expresiones() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:41:12: ( ZONAREGLA ( reglas )* ZONAREGLA )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:41:14: ZONAREGLA ( reglas )* ZONAREGLA
            {
            match(input,ZONAREGLA,FOLLOW_ZONAREGLA_in_expresiones419); 

            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:41:24: ( reglas )*
            loop24:
            do {
                int alt24=2;
                int LA24_0 = input.LA(1);

                if ( (LA24_0==IDENT) ) {
                    alt24=1;
                }


                switch (alt24) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:41:24: reglas
            	    {
            	    pushFollow(FOLLOW_reglas_in_expresiones421);
            	    reglas();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop24;
                }
            } while (true);


            match(input,ZONAREGLA,FOLLOW_ZONAREGLA_in_expresiones424); 

            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "expresiones"



    // $ANTLR start "reglas"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:42:1: reglas : IDENT DOSPUNTOS ( patron )? ( ORYACC patron )* SEPARADOR ;
    public final void reglas() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:42:7: ( IDENT DOSPUNTOS ( patron )? ( ORYACC patron )* SEPARADOR )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:42:9: IDENT DOSPUNTOS ( patron )? ( ORYACC patron )* SEPARADOR
            {
            match(input,IDENT,FOLLOW_IDENT_in_reglas430); 

            match(input,DOSPUNTOS,FOLLOW_DOSPUNTOS_in_reglas432); 

            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:42:25: ( patron )?
            int alt25=2;
            int LA25_0 = input.LA(1);

            if ( (LA25_0==CARACTER||LA25_0==IDENT||LA25_0==PORCENTAJE) ) {
                alt25=1;
            }
            switch (alt25) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:42:25: patron
                    {
                    pushFollow(FOLLOW_patron_in_reglas434);
                    patron();

                    state._fsp--;


                    }
                    break;

            }


            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:42:33: ( ORYACC patron )*
            loop26:
            do {
                int alt26=2;
                int LA26_0 = input.LA(1);

                if ( (LA26_0==ORYACC) ) {
                    alt26=1;
                }


                switch (alt26) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:42:34: ORYACC patron
            	    {
            	    match(input,ORYACC,FOLLOW_ORYACC_in_reglas438); 

            	    pushFollow(FOLLOW_patron_in_reglas440);
            	    patron();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop26;
                }
            } while (true);


            match(input,SEPARADOR,FOLLOW_SEPARADOR_in_reglas444); 

            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "reglas"



    // $ANTLR start "patron"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:43:1: patron : ( CARACTER | ( PORCENTAJE )? IDENT )+ ( def_cuerpo )? ;
    public final void patron() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:43:7: ( ( CARACTER | ( PORCENTAJE )? IDENT )+ ( def_cuerpo )? )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:43:9: ( CARACTER | ( PORCENTAJE )? IDENT )+ ( def_cuerpo )?
            {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:43:9: ( CARACTER | ( PORCENTAJE )? IDENT )+
            int cnt28=0;
            loop28:
            do {
                int alt28=3;
                int LA28_0 = input.LA(1);

                if ( (LA28_0==CARACTER) ) {
                    alt28=1;
                }
                else if ( (LA28_0==IDENT||LA28_0==PORCENTAJE) ) {
                    alt28=2;
                }


                switch (alt28) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:43:10: CARACTER
            	    {
            	    match(input,CARACTER,FOLLOW_CARACTER_in_patron451); 

            	    }
            	    break;
            	case 2 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:43:20: ( PORCENTAJE )? IDENT
            	    {
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:43:20: ( PORCENTAJE )?
            	    int alt27=2;
            	    int LA27_0 = input.LA(1);

            	    if ( (LA27_0==PORCENTAJE) ) {
            	        alt27=1;
            	    }
            	    switch (alt27) {
            	        case 1 :
            	            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:43:20: PORCENTAJE
            	            {
            	            match(input,PORCENTAJE,FOLLOW_PORCENTAJE_in_patron454); 

            	            }
            	            break;

            	    }


            	    match(input,IDENT,FOLLOW_IDENT_in_patron457); 

            	    }
            	    break;

            	default :
            	    if ( cnt28 >= 1 ) break loop28;
                        EarlyExitException eee =
                            new EarlyExitException(28, input);
                        throw eee;
                }
                cnt28++;
            } while (true);


            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:43:40: ( def_cuerpo )?
            int alt29=2;
            int LA29_0 = input.LA(1);

            if ( (LA29_0==ALLAVE) ) {
                alt29=1;
            }
            switch (alt29) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:43:40: def_cuerpo
                    {
                    pushFollow(FOLLOW_def_cuerpo_in_patron461);
                    def_cuerpo();

                    state._fsp--;


                    }
                    break;

            }


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "patron"



    // $ANTLR start "llamada_funcion"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:44:1: llamada_funcion : IDENT APARENTESIS ( operacion )? ( segundo_param )* CPARENTESIS ;
    public final void llamada_funcion() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:44:16: ( IDENT APARENTESIS ( operacion )? ( segundo_param )* CPARENTESIS )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:44:18: IDENT APARENTESIS ( operacion )? ( segundo_param )* CPARENTESIS
            {
            match(input,IDENT,FOLLOW_IDENT_in_llamada_funcion468); 

            match(input,APARENTESIS,FOLLOW_APARENTESIS_in_llamada_funcion470); 

            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:44:36: ( operacion )?
            int alt30=2;
            int LA30_0 = input.LA(1);

            if ( (LA30_0==ASTERISCO||(LA30_0 >= CADENA && LA30_0 <= CARACTER)||LA30_0==DOLARDOLAR||LA30_0==IDENT||LA30_0==MENOS||LA30_0==NUMERO||LA30_0==VAR) ) {
                alt30=1;
            }
            switch (alt30) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:44:37: operacion
                    {
                    pushFollow(FOLLOW_operacion_in_llamada_funcion473);
                    operacion();

                    state._fsp--;


                    }
                    break;

            }


            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:44:49: ( segundo_param )*
            loop31:
            do {
                int alt31=2;
                int LA31_0 = input.LA(1);

                if ( (LA31_0==COMA) ) {
                    alt31=1;
                }


                switch (alt31) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:44:50: segundo_param
            	    {
            	    pushFollow(FOLLOW_segundo_param_in_llamada_funcion478);
            	    segundo_param();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop31;
                }
            } while (true);


            match(input,CPARENTESIS,FOLLOW_CPARENTESIS_in_llamada_funcion482); 

            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "llamada_funcion"



    // $ANTLR start "segundo_param"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:45:1: segundo_param : COMA ( operacion ) ;
    public final void segundo_param() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:45:14: ( COMA ( operacion ) )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:45:16: COMA ( operacion )
            {
            match(input,COMA,FOLLOW_COMA_in_segundo_param488); 

            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:45:21: ( operacion )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:45:22: operacion
            {
            pushFollow(FOLLOW_operacion_in_segundo_param491);
            operacion();

            state._fsp--;


            }


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "segundo_param"



    // $ANTLR start "partec"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:48:1: partec : ( declaracionc )? ( declaracion )* ( funcion )+ ;
    public final void partec() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:48:7: ( ( declaracionc )? ( declaracion )* ( funcion )+ )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:48:9: ( declaracionc )? ( declaracion )* ( funcion )+
            {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:48:9: ( declaracionc )?
            int alt32=2;
            alt32 = dfa32.predict(input);
            switch (alt32) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:48:9: declaracionc
                    {
                    pushFollow(FOLLOW_declaracionc_in_partec501);
                    declaracionc();

                    state._fsp--;


                    }
                    break;

            }


            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:48:23: ( declaracion )*
            loop33:
            do {
                int alt33=2;
                int LA33_0 = input.LA(1);

                if ( (LA33_0==EXTERN) ) {
                    alt33=1;
                }


                switch (alt33) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:48:23: declaracion
            	    {
            	    pushFollow(FOLLOW_declaracion_in_partec504);
            	    declaracion();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop33;
                }
            } while (true);


            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:48:36: ( funcion )+
            int cnt34=0;
            loop34:
            do {
                int alt34=2;
                int LA34_0 = input.LA(1);

                if ( (LA34_0==IDENT||LA34_0==MAIN||LA34_0==TIPO||LA34_0==VOID) ) {
                    alt34=1;
                }


                switch (alt34) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:48:36: funcion
            	    {
            	    pushFollow(FOLLOW_funcion_in_partec507);
            	    funcion();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    if ( cnt34 >= 1 ) break loop34;
                        EarlyExitException eee =
                            new EarlyExitException(34, input);
                        throw eee;
                }
                cnt34++;
            } while (true);


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "partec"



    // $ANTLR start "declaracion"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:49:1: declaracion : EXTERN IDENT ( ASTERISCO )? IDENT SEPARADOR ;
    public final void declaracion() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:49:12: ( EXTERN IDENT ( ASTERISCO )? IDENT SEPARADOR )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:49:14: EXTERN IDENT ( ASTERISCO )? IDENT SEPARADOR
            {
            match(input,EXTERN,FOLLOW_EXTERN_in_declaracion514); 

            match(input,IDENT,FOLLOW_IDENT_in_declaracion516); 

            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:49:27: ( ASTERISCO )?
            int alt35=2;
            int LA35_0 = input.LA(1);

            if ( (LA35_0==ASTERISCO) ) {
                alt35=1;
            }
            switch (alt35) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:49:27: ASTERISCO
                    {
                    match(input,ASTERISCO,FOLLOW_ASTERISCO_in_declaracion518); 

                    }
                    break;

            }


            match(input,IDENT,FOLLOW_IDENT_in_declaracion521); 

            match(input,SEPARADOR,FOLLOW_SEPARADOR_in_declaracion523); 

            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "declaracion"



    // $ANTLR start "funcion"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:51:1: funcion : def_funcion def_cuerpo ;
    public final void funcion() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:51:8: ( def_funcion def_cuerpo )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:51:10: def_funcion def_cuerpo
            {
            pushFollow(FOLLOW_def_funcion_in_funcion530);
            def_funcion();

            state._fsp--;


            pushFollow(FOLLOW_def_cuerpo_in_funcion532);
            def_cuerpo();

            state._fsp--;


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "funcion"



    // $ANTLR start "def_funcion"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:52:1: def_funcion : ( TIPO | VOID | IDENT )? ( IDENT | MAIN ) APARENTESIS ( VOID | ( ( llamada_variable | IDENT ) ( COMA ( llamada_variable | IDENT ) )* )? ) CPARENTESIS ( definicion )* ;
    public final void def_funcion() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:52:12: ( ( TIPO | VOID | IDENT )? ( IDENT | MAIN ) APARENTESIS ( VOID | ( ( llamada_variable | IDENT ) ( COMA ( llamada_variable | IDENT ) )* )? ) CPARENTESIS ( definicion )* )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:52:14: ( TIPO | VOID | IDENT )? ( IDENT | MAIN ) APARENTESIS ( VOID | ( ( llamada_variable | IDENT ) ( COMA ( llamada_variable | IDENT ) )* )? ) CPARENTESIS ( definicion )*
            {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:52:14: ( TIPO | VOID | IDENT )?
            int alt36=2;
            int LA36_0 = input.LA(1);

            if ( (LA36_0==IDENT) ) {
                int LA36_1 = input.LA(2);

                if ( (LA36_1==IDENT||LA36_1==MAIN) ) {
                    alt36=1;
                }
            }
            else if ( (LA36_0==TIPO||LA36_0==VOID) ) {
                alt36=1;
            }
            switch (alt36) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:
                    {
                    if ( input.LA(1)==IDENT||input.LA(1)==TIPO||input.LA(1)==VOID ) {
                        input.consume();
                        state.errorRecovery=false;
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        throw mse;
                    }


                    }
                    break;

            }


            if ( input.LA(1)==IDENT||input.LA(1)==MAIN ) {
                input.consume();
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            match(input,APARENTESIS,FOLLOW_APARENTESIS_in_def_funcion553); 

            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:52:58: ( VOID | ( ( llamada_variable | IDENT ) ( COMA ( llamada_variable | IDENT ) )* )? )
            int alt41=2;
            int LA41_0 = input.LA(1);

            if ( (LA41_0==VOID) ) {
                alt41=1;
            }
            else if ( (LA41_0==CPARENTESIS||LA41_0==IDENT||LA41_0==TIPO) ) {
                alt41=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 41, 0, input);

                throw nvae;

            }
            switch (alt41) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:52:59: VOID
                    {
                    match(input,VOID,FOLLOW_VOID_in_def_funcion556); 

                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:52:66: ( ( llamada_variable | IDENT ) ( COMA ( llamada_variable | IDENT ) )* )?
                    {
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:52:66: ( ( llamada_variable | IDENT ) ( COMA ( llamada_variable | IDENT ) )* )?
                    int alt40=2;
                    int LA40_0 = input.LA(1);

                    if ( (LA40_0==IDENT||LA40_0==TIPO) ) {
                        alt40=1;
                    }
                    switch (alt40) {
                        case 1 :
                            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:52:67: ( llamada_variable | IDENT ) ( COMA ( llamada_variable | IDENT ) )*
                            {
                            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:52:67: ( llamada_variable | IDENT )
                            int alt37=2;
                            int LA37_0 = input.LA(1);

                            if ( (LA37_0==TIPO) ) {
                                alt37=1;
                            }
                            else if ( (LA37_0==IDENT) ) {
                                alt37=2;
                            }
                            else {
                                NoViableAltException nvae =
                                    new NoViableAltException("", 37, 0, input);

                                throw nvae;

                            }
                            switch (alt37) {
                                case 1 :
                                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:52:68: llamada_variable
                                    {
                                    pushFollow(FOLLOW_llamada_variable_in_def_funcion562);
                                    llamada_variable();

                                    state._fsp--;


                                    }
                                    break;
                                case 2 :
                                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:52:86: IDENT
                                    {
                                    match(input,IDENT,FOLLOW_IDENT_in_def_funcion565); 

                                    }
                                    break;

                            }


                            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:52:93: ( COMA ( llamada_variable | IDENT ) )*
                            loop39:
                            do {
                                int alt39=2;
                                int LA39_0 = input.LA(1);

                                if ( (LA39_0==COMA) ) {
                                    alt39=1;
                                }


                                switch (alt39) {
                            	case 1 :
                            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:52:94: COMA ( llamada_variable | IDENT )
                            	    {
                            	    match(input,COMA,FOLLOW_COMA_in_def_funcion569); 

                            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:52:99: ( llamada_variable | IDENT )
                            	    int alt38=2;
                            	    int LA38_0 = input.LA(1);

                            	    if ( (LA38_0==TIPO) ) {
                            	        alt38=1;
                            	    }
                            	    else if ( (LA38_0==IDENT) ) {
                            	        alt38=2;
                            	    }
                            	    else {
                            	        NoViableAltException nvae =
                            	            new NoViableAltException("", 38, 0, input);

                            	        throw nvae;

                            	    }
                            	    switch (alt38) {
                            	        case 1 :
                            	            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:52:100: llamada_variable
                            	            {
                            	            pushFollow(FOLLOW_llamada_variable_in_def_funcion572);
                            	            llamada_variable();

                            	            state._fsp--;


                            	            }
                            	            break;
                            	        case 2 :
                            	            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:52:119: IDENT
                            	            {
                            	            match(input,IDENT,FOLLOW_IDENT_in_def_funcion576); 

                            	            }
                            	            break;

                            	    }


                            	    }
                            	    break;

                            	default :
                            	    break loop39;
                                }
                            } while (true);


                            }
                            break;

                    }


                    }
                    break;

            }


            match(input,CPARENTESIS,FOLLOW_CPARENTESIS_in_def_funcion584); 

            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:52:143: ( definicion )*
            loop42:
            do {
                int alt42=2;
                int LA42_0 = input.LA(1);

                if ( (LA42_0==IDENT||LA42_0==TIPO) ) {
                    alt42=1;
                }


                switch (alt42) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:52:143: definicion
            	    {
            	    pushFollow(FOLLOW_definicion_in_def_funcion586);
            	    definicion();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop42;
                }
            } while (true);


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "def_funcion"



    // $ANTLR start "llamada_variable"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:53:1: llamada_variable : TIPO ( ASTERISCO )* IDENT ( ACORCHETE CCORCHETE )? ;
    public final void llamada_variable() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:53:17: ( TIPO ( ASTERISCO )* IDENT ( ACORCHETE CCORCHETE )? )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:53:19: TIPO ( ASTERISCO )* IDENT ( ACORCHETE CCORCHETE )?
            {
            match(input,TIPO,FOLLOW_TIPO_in_llamada_variable593); 

            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:53:24: ( ASTERISCO )*
            loop43:
            do {
                int alt43=2;
                int LA43_0 = input.LA(1);

                if ( (LA43_0==ASTERISCO) ) {
                    alt43=1;
                }


                switch (alt43) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:53:25: ASTERISCO
            	    {
            	    match(input,ASTERISCO,FOLLOW_ASTERISCO_in_llamada_variable596); 

            	    }
            	    break;

            	default :
            	    break loop43;
                }
            } while (true);


            match(input,IDENT,FOLLOW_IDENT_in_llamada_variable600); 

            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:53:43: ( ACORCHETE CCORCHETE )?
            int alt44=2;
            int LA44_0 = input.LA(1);

            if ( (LA44_0==ACORCHETE) ) {
                alt44=1;
            }
            switch (alt44) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:53:44: ACORCHETE CCORCHETE
                    {
                    match(input,ACORCHETE,FOLLOW_ACORCHETE_in_llamada_variable603); 

                    match(input,CCORCHETE,FOLLOW_CCORCHETE_in_llamada_variable605); 

                    }
                    break;

            }


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "llamada_variable"



    // $ANTLR start "def_cuerpo"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:55:1: def_cuerpo : ALLAVE ( sentencia | definicion | retorno | bucles )* CLLAVE ;
    public final void def_cuerpo() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:55:11: ( ALLAVE ( sentencia | definicion | retorno | bucles )* CLLAVE )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:55:13: ALLAVE ( sentencia | definicion | retorno | bucles )* CLLAVE
            {
            match(input,ALLAVE,FOLLOW_ALLAVE_in_def_cuerpo614); 

            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:55:20: ( sentencia | definicion | retorno | bucles )*
            loop45:
            do {
                int alt45=5;
                switch ( input.LA(1) ) {
                case ASTERISCO:
                case DOLARDOLAR:
                case VAR:
                    {
                    alt45=1;
                    }
                    break;
                case IDENT:
                    {
                    int LA45_3 = input.LA(2);

                    if ( (LA45_3==ACORCHETE||LA45_3==APARENTESIS||LA45_3==COMA||LA45_3==IGUAL||LA45_3==PUNTO||LA45_3==SEPARADOR) ) {
                        alt45=1;
                    }
                    else if ( (LA45_3==ASTERISCO||LA45_3==DOLARDOLAR||LA45_3==IDENT||LA45_3==VAR) ) {
                        alt45=2;
                    }


                    }
                    break;
                case TIPO:
                    {
                    alt45=2;
                    }
                    break;
                case RETURN:
                    {
                    alt45=3;
                    }
                    break;
                case FOR:
                case IF:
                case WHILE:
                    {
                    alt45=4;
                    }
                    break;

                }

                switch (alt45) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:55:21: sentencia
            	    {
            	    pushFollow(FOLLOW_sentencia_in_def_cuerpo617);
            	    sentencia();

            	    state._fsp--;


            	    }
            	    break;
            	case 2 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:55:31: definicion
            	    {
            	    pushFollow(FOLLOW_definicion_in_def_cuerpo619);
            	    definicion();

            	    state._fsp--;


            	    }
            	    break;
            	case 3 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:55:42: retorno
            	    {
            	    pushFollow(FOLLOW_retorno_in_def_cuerpo621);
            	    retorno();

            	    state._fsp--;


            	    }
            	    break;
            	case 4 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:55:50: bucles
            	    {
            	    pushFollow(FOLLOW_bucles_in_def_cuerpo623);
            	    bucles();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop45;
                }
            } while (true);


            match(input,CLLAVE,FOLLOW_CLLAVE_in_def_cuerpo627); 

            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "def_cuerpo"



    // $ANTLR start "retorno"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:56:1: retorno : RETURN ( APARENTESIS subsentencia CPARENTESIS | subsentencia ) SEPARADOR ;
    public final void retorno() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:56:8: ( RETURN ( APARENTESIS subsentencia CPARENTESIS | subsentencia ) SEPARADOR )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:56:10: RETURN ( APARENTESIS subsentencia CPARENTESIS | subsentencia ) SEPARADOR
            {
            match(input,RETURN,FOLLOW_RETURN_in_retorno633); 

            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:56:17: ( APARENTESIS subsentencia CPARENTESIS | subsentencia )
            int alt46=2;
            int LA46_0 = input.LA(1);

            if ( (LA46_0==APARENTESIS) ) {
                alt46=1;
            }
            else if ( (LA46_0==ASTERISCO||(LA46_0 >= CADENA && LA46_0 <= CARACTER)||LA46_0==DOLARDOLAR||LA46_0==IDENT||LA46_0==NUMERO||LA46_0==VAR) ) {
                alt46=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 46, 0, input);

                throw nvae;

            }
            switch (alt46) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:56:18: APARENTESIS subsentencia CPARENTESIS
                    {
                    match(input,APARENTESIS,FOLLOW_APARENTESIS_in_retorno636); 

                    pushFollow(FOLLOW_subsentencia_in_retorno638);
                    subsentencia();

                    state._fsp--;


                    match(input,CPARENTESIS,FOLLOW_CPARENTESIS_in_retorno640); 

                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:56:57: subsentencia
                    {
                    pushFollow(FOLLOW_subsentencia_in_retorno644);
                    subsentencia();

                    state._fsp--;


                    }
                    break;

            }


            match(input,SEPARADOR,FOLLOW_SEPARADOR_in_retorno647); 

            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "retorno"



    // $ANTLR start "comparacion"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:58:1: comparacion : APARENTESIS reglascond ( ( AND | OR ) reglascond )* CPARENTESIS ;
    public final void comparacion() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:58:12: ( APARENTESIS reglascond ( ( AND | OR ) reglascond )* CPARENTESIS )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:58:13: APARENTESIS reglascond ( ( AND | OR ) reglascond )* CPARENTESIS
            {
            match(input,APARENTESIS,FOLLOW_APARENTESIS_in_comparacion653); 

            pushFollow(FOLLOW_reglascond_in_comparacion655);
            reglascond();

            state._fsp--;


            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:58:36: ( ( AND | OR ) reglascond )*
            loop47:
            do {
                int alt47=2;
                int LA47_0 = input.LA(1);

                if ( (LA47_0==AND||LA47_0==OR) ) {
                    alt47=1;
                }


                switch (alt47) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:58:37: ( AND | OR ) reglascond
            	    {
            	    if ( input.LA(1)==AND||input.LA(1)==OR ) {
            	        input.consume();
            	        state.errorRecovery=false;
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    pushFollow(FOLLOW_reglascond_in_comparacion666);
            	    reglascond();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop47;
                }
            } while (true);


            match(input,CPARENTESIS,FOLLOW_CPARENTESIS_in_comparacion670); 

            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "comparacion"



    // $ANTLR start "igualarencond"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:59:1: igualarencond : ( APARENTESIS operacion ( IGUAL operacion )? CPARENTESIS | operacion );
    public final void igualarencond() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:59:14: ( APARENTESIS operacion ( IGUAL operacion )? CPARENTESIS | operacion )
            int alt49=2;
            int LA49_0 = input.LA(1);

            if ( (LA49_0==APARENTESIS) ) {
                alt49=1;
            }
            else if ( (LA49_0==ASTERISCO||(LA49_0 >= CADENA && LA49_0 <= CARACTER)||LA49_0==DOLARDOLAR||LA49_0==IDENT||LA49_0==MENOS||LA49_0==NUMERO||LA49_0==VAR) ) {
                alt49=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 49, 0, input);

                throw nvae;

            }
            switch (alt49) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:59:16: APARENTESIS operacion ( IGUAL operacion )? CPARENTESIS
                    {
                    match(input,APARENTESIS,FOLLOW_APARENTESIS_in_igualarencond676); 

                    pushFollow(FOLLOW_operacion_in_igualarencond678);
                    operacion();

                    state._fsp--;


                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:59:38: ( IGUAL operacion )?
                    int alt48=2;
                    int LA48_0 = input.LA(1);

                    if ( (LA48_0==IGUAL) ) {
                        alt48=1;
                    }
                    switch (alt48) {
                        case 1 :
                            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:59:39: IGUAL operacion
                            {
                            match(input,IGUAL,FOLLOW_IGUAL_in_igualarencond681); 

                            pushFollow(FOLLOW_operacion_in_igualarencond683);
                            operacion();

                            state._fsp--;


                            }
                            break;

                    }


                    match(input,CPARENTESIS,FOLLOW_CPARENTESIS_in_igualarencond687); 

                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:59:70: operacion
                    {
                    pushFollow(FOLLOW_operacion_in_igualarencond690);
                    operacion();

                    state._fsp--;


                    }
                    break;

            }
        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "igualarencond"



    // $ANTLR start "reglascond"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:60:1: reglascond : ( NOT )? ( ( igualarencond ( ( MAYOR ( IGUAL )? | MENOR ( IGUAL )? | IGUAL IGUAL ) igualarencond )? ) | cond_aritmetico | IDENT MAS MAS ) ;
    public final void reglascond() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:60:11: ( ( NOT )? ( ( igualarencond ( ( MAYOR ( IGUAL )? | MENOR ( IGUAL )? | IGUAL IGUAL ) igualarencond )? ) | cond_aritmetico | IDENT MAS MAS ) )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:60:12: ( NOT )? ( ( igualarencond ( ( MAYOR ( IGUAL )? | MENOR ( IGUAL )? | IGUAL IGUAL ) igualarencond )? ) | cond_aritmetico | IDENT MAS MAS )
            {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:60:12: ( NOT )?
            int alt50=2;
            int LA50_0 = input.LA(1);

            if ( (LA50_0==NOT) ) {
                alt50=1;
            }
            switch (alt50) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:60:12: NOT
                    {
                    match(input,NOT,FOLLOW_NOT_in_reglascond695); 

                    }
                    break;

            }


            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:60:16: ( ( igualarencond ( ( MAYOR ( IGUAL )? | MENOR ( IGUAL )? | IGUAL IGUAL ) igualarencond )? ) | cond_aritmetico | IDENT MAS MAS )
            int alt55=3;
            int LA55_0 = input.LA(1);

            if ( ((LA55_0 >= APARENTESIS && LA55_0 <= ASTERISCO)||(LA55_0 >= CADENA && LA55_0 <= CARACTER)||LA55_0==DOLARDOLAR||LA55_0==MENOS||LA55_0==NUMERO||LA55_0==VAR) ) {
                alt55=1;
            }
            else if ( (LA55_0==IDENT) ) {
                switch ( input.LA(2) ) {
                case ACORCHETE:
                case AND:
                case APARENTESIS:
                case ASTERISCO:
                case BARRA:
                case CPARENTESIS:
                case MENOS:
                case OR:
                case PUNTO:
                    {
                    alt55=1;
                    }
                    break;
                case MAS:
                    {
                    int LA55_3 = input.LA(3);

                    if ( (LA55_3==MAS) ) {
                        alt55=3;
                    }
                    else if ( (LA55_3==ASTERISCO||(LA55_3 >= CADENA && LA55_3 <= CARACTER)||LA55_3==DOLARDOLAR||LA55_3==IDENT||LA55_3==MENOS||LA55_3==NUMERO||LA55_3==VAR) ) {
                        alt55=1;
                    }
                    else {
                        NoViableAltException nvae =
                            new NoViableAltException("", 55, 3, input);

                        throw nvae;

                    }
                    }
                    break;
                case MAYOR:
                    {
                    switch ( input.LA(3) ) {
                    case IGUAL:
                        {
                        int LA55_8 = input.LA(4);

                        if ( ((LA55_8 >= APARENTESIS && LA55_8 <= ASTERISCO)||(LA55_8 >= CADENA && LA55_8 <= CARACTER)||LA55_8==DOLARDOLAR||LA55_8==IDENT||LA55_8==MENOS||LA55_8==VAR) ) {
                            alt55=1;
                        }
                        else if ( (LA55_8==NUMERO) ) {
                            int LA55_9 = input.LA(5);

                            if ( (LA55_9==INTERROGANTE) ) {
                                alt55=2;
                            }
                            else if ( (LA55_9==AND||(LA55_9 >= ASTERISCO && LA55_9 <= BARRA)||LA55_9==CPARENTESIS||LA55_9==MAS||LA55_9==MENOS||LA55_9==OR) ) {
                                alt55=1;
                            }
                            else {
                                NoViableAltException nvae =
                                    new NoViableAltException("", 55, 9, input);

                                throw nvae;

                            }
                        }
                        else {
                            NoViableAltException nvae =
                                new NoViableAltException("", 55, 8, input);

                            throw nvae;

                        }
                        }
                        break;
                    case APARENTESIS:
                    case ASTERISCO:
                    case CADENA:
                    case CARACTER:
                    case DOLARDOLAR:
                    case IDENT:
                    case MENOS:
                    case VAR:
                        {
                        alt55=1;
                        }
                        break;
                    case NUMERO:
                        {
                        int LA55_9 = input.LA(4);

                        if ( (LA55_9==INTERROGANTE) ) {
                            alt55=2;
                        }
                        else if ( (LA55_9==AND||(LA55_9 >= ASTERISCO && LA55_9 <= BARRA)||LA55_9==CPARENTESIS||LA55_9==MAS||LA55_9==MENOS||LA55_9==OR) ) {
                            alt55=1;
                        }
                        else {
                            NoViableAltException nvae =
                                new NoViableAltException("", 55, 9, input);

                            throw nvae;

                        }
                        }
                        break;
                    default:
                        NoViableAltException nvae =
                            new NoViableAltException("", 55, 4, input);

                        throw nvae;

                    }

                    }
                    break;
                case MENOR:
                    {
                    switch ( input.LA(3) ) {
                    case IGUAL:
                        {
                        int LA55_10 = input.LA(4);

                        if ( ((LA55_10 >= APARENTESIS && LA55_10 <= ASTERISCO)||(LA55_10 >= CADENA && LA55_10 <= CARACTER)||LA55_10==DOLARDOLAR||LA55_10==IDENT||LA55_10==MENOS||LA55_10==VAR) ) {
                            alt55=1;
                        }
                        else if ( (LA55_10==NUMERO) ) {
                            int LA55_9 = input.LA(5);

                            if ( (LA55_9==INTERROGANTE) ) {
                                alt55=2;
                            }
                            else if ( (LA55_9==AND||(LA55_9 >= ASTERISCO && LA55_9 <= BARRA)||LA55_9==CPARENTESIS||LA55_9==MAS||LA55_9==MENOS||LA55_9==OR) ) {
                                alt55=1;
                            }
                            else {
                                NoViableAltException nvae =
                                    new NoViableAltException("", 55, 9, input);

                                throw nvae;

                            }
                        }
                        else {
                            NoViableAltException nvae =
                                new NoViableAltException("", 55, 10, input);

                            throw nvae;

                        }
                        }
                        break;
                    case APARENTESIS:
                    case ASTERISCO:
                    case CADENA:
                    case CARACTER:
                    case DOLARDOLAR:
                    case IDENT:
                    case MENOS:
                    case VAR:
                        {
                        alt55=1;
                        }
                        break;
                    case NUMERO:
                        {
                        int LA55_9 = input.LA(4);

                        if ( (LA55_9==INTERROGANTE) ) {
                            alt55=2;
                        }
                        else if ( (LA55_9==AND||(LA55_9 >= ASTERISCO && LA55_9 <= BARRA)||LA55_9==CPARENTESIS||LA55_9==MAS||LA55_9==MENOS||LA55_9==OR) ) {
                            alt55=1;
                        }
                        else {
                            NoViableAltException nvae =
                                new NoViableAltException("", 55, 9, input);

                            throw nvae;

                        }
                        }
                        break;
                    default:
                        NoViableAltException nvae =
                            new NoViableAltException("", 55, 5, input);

                        throw nvae;

                    }

                    }
                    break;
                case IGUAL:
                    {
                    int LA55_6 = input.LA(3);

                    if ( (LA55_6==IGUAL) ) {
                        int LA55_11 = input.LA(4);

                        if ( ((LA55_11 >= APARENTESIS && LA55_11 <= ASTERISCO)||(LA55_11 >= CADENA && LA55_11 <= CARACTER)||LA55_11==DOLARDOLAR||LA55_11==IDENT||LA55_11==MENOS||LA55_11==VAR) ) {
                            alt55=1;
                        }
                        else if ( (LA55_11==NUMERO) ) {
                            int LA55_9 = input.LA(5);

                            if ( (LA55_9==INTERROGANTE) ) {
                                alt55=2;
                            }
                            else if ( (LA55_9==AND||(LA55_9 >= ASTERISCO && LA55_9 <= BARRA)||LA55_9==CPARENTESIS||LA55_9==MAS||LA55_9==MENOS||LA55_9==OR) ) {
                                alt55=1;
                            }
                            else {
                                NoViableAltException nvae =
                                    new NoViableAltException("", 55, 9, input);

                                throw nvae;

                            }
                        }
                        else {
                            NoViableAltException nvae =
                                new NoViableAltException("", 55, 11, input);

                            throw nvae;

                        }
                    }
                    else {
                        NoViableAltException nvae =
                            new NoViableAltException("", 55, 6, input);

                        throw nvae;

                    }
                    }
                    break;
                default:
                    NoViableAltException nvae =
                        new NoViableAltException("", 55, 2, input);

                    throw nvae;

                }

            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 55, 0, input);

                throw nvae;

            }
            switch (alt55) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:60:17: ( igualarencond ( ( MAYOR ( IGUAL )? | MENOR ( IGUAL )? | IGUAL IGUAL ) igualarencond )? )
                    {
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:60:17: ( igualarencond ( ( MAYOR ( IGUAL )? | MENOR ( IGUAL )? | IGUAL IGUAL ) igualarencond )? )
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:60:19: igualarencond ( ( MAYOR ( IGUAL )? | MENOR ( IGUAL )? | IGUAL IGUAL ) igualarencond )?
                    {
                    pushFollow(FOLLOW_igualarencond_in_reglascond700);
                    igualarencond();

                    state._fsp--;


                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:60:33: ( ( MAYOR ( IGUAL )? | MENOR ( IGUAL )? | IGUAL IGUAL ) igualarencond )?
                    int alt54=2;
                    int LA54_0 = input.LA(1);

                    if ( (LA54_0==IGUAL||(LA54_0 >= MAYOR && LA54_0 <= MENOR)) ) {
                        alt54=1;
                    }
                    switch (alt54) {
                        case 1 :
                            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:60:34: ( MAYOR ( IGUAL )? | MENOR ( IGUAL )? | IGUAL IGUAL ) igualarencond
                            {
                            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:60:34: ( MAYOR ( IGUAL )? | MENOR ( IGUAL )? | IGUAL IGUAL )
                            int alt53=3;
                            switch ( input.LA(1) ) {
                            case MAYOR:
                                {
                                alt53=1;
                                }
                                break;
                            case MENOR:
                                {
                                alt53=2;
                                }
                                break;
                            case IGUAL:
                                {
                                alt53=3;
                                }
                                break;
                            default:
                                NoViableAltException nvae =
                                    new NoViableAltException("", 53, 0, input);

                                throw nvae;

                            }

                            switch (alt53) {
                                case 1 :
                                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:60:35: MAYOR ( IGUAL )?
                                    {
                                    match(input,MAYOR,FOLLOW_MAYOR_in_reglascond704); 

                                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:60:41: ( IGUAL )?
                                    int alt51=2;
                                    int LA51_0 = input.LA(1);

                                    if ( (LA51_0==IGUAL) ) {
                                        alt51=1;
                                    }
                                    switch (alt51) {
                                        case 1 :
                                            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:60:41: IGUAL
                                            {
                                            match(input,IGUAL,FOLLOW_IGUAL_in_reglascond706); 

                                            }
                                            break;

                                    }


                                    }
                                    break;
                                case 2 :
                                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:60:48: MENOR ( IGUAL )?
                                    {
                                    match(input,MENOR,FOLLOW_MENOR_in_reglascond709); 

                                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:60:54: ( IGUAL )?
                                    int alt52=2;
                                    int LA52_0 = input.LA(1);

                                    if ( (LA52_0==IGUAL) ) {
                                        alt52=1;
                                    }
                                    switch (alt52) {
                                        case 1 :
                                            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:60:54: IGUAL
                                            {
                                            match(input,IGUAL,FOLLOW_IGUAL_in_reglascond711); 

                                            }
                                            break;

                                    }


                                    }
                                    break;
                                case 3 :
                                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:60:62: IGUAL IGUAL
                                    {
                                    match(input,IGUAL,FOLLOW_IGUAL_in_reglascond715); 

                                    match(input,IGUAL,FOLLOW_IGUAL_in_reglascond717); 

                                    }
                                    break;

                            }


                            pushFollow(FOLLOW_igualarencond_in_reglascond720);
                            igualarencond();

                            state._fsp--;


                            }
                            break;

                    }


                    }


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:60:93: cond_aritmetico
                    {
                    pushFollow(FOLLOW_cond_aritmetico_in_reglascond726);
                    cond_aritmetico();

                    state._fsp--;


                    }
                    break;
                case 3 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:60:110: IDENT MAS MAS
                    {
                    match(input,IDENT,FOLLOW_IDENT_in_reglascond729); 

                    match(input,MAS,FOLLOW_MAS_in_reglascond731); 

                    match(input,MAS,FOLLOW_MAS_in_reglascond733); 

                    }
                    break;

            }


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "reglascond"



    // $ANTLR start "bucle"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:61:1: bucle : WHILE comparacion ;
    public final void bucle() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:61:6: ( WHILE comparacion )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:61:8: WHILE comparacion
            {
            match(input,WHILE,FOLLOW_WHILE_in_bucle740); 

            pushFollow(FOLLOW_comparacion_in_bucle742);
            comparacion();

            state._fsp--;


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "bucle"



    // $ANTLR start "buclefor"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:62:1: buclefor : FOR comparacion_for ;
    public final void buclefor() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:62:9: ( FOR comparacion_for )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:62:11: FOR comparacion_for
            {
            match(input,FOR,FOLLOW_FOR_in_buclefor750); 

            pushFollow(FOLLOW_comparacion_for_in_buclefor752);
            comparacion_for();

            state._fsp--;


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "buclefor"



    // $ANTLR start "comparacion_for"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:63:1: comparacion_for : APARENTESIS ( comparacion1 )? SEPARADOR ( comparacion2 )? SEPARADOR ( comparacion3 )? CPARENTESIS ;
    public final void comparacion_for() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:63:16: ( APARENTESIS ( comparacion1 )? SEPARADOR ( comparacion2 )? SEPARADOR ( comparacion3 )? CPARENTESIS )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:63:18: APARENTESIS ( comparacion1 )? SEPARADOR ( comparacion2 )? SEPARADOR ( comparacion3 )? CPARENTESIS
            {
            match(input,APARENTESIS,FOLLOW_APARENTESIS_in_comparacion_for758); 

            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:63:30: ( comparacion1 )?
            int alt56=2;
            int LA56_0 = input.LA(1);

            if ( (LA56_0==IDENT||LA56_0==TIPO) ) {
                alt56=1;
            }
            switch (alt56) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:63:30: comparacion1
                    {
                    pushFollow(FOLLOW_comparacion1_in_comparacion_for760);
                    comparacion1();

                    state._fsp--;


                    }
                    break;

            }


            match(input,SEPARADOR,FOLLOW_SEPARADOR_in_comparacion_for763); 

            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:63:54: ( comparacion2 )?
            int alt57=2;
            int LA57_0 = input.LA(1);

            if ( ((LA57_0 >= APARENTESIS && LA57_0 <= ASTERISCO)||LA57_0==DOLARDOLAR||LA57_0==IDENT||LA57_0==VAR) ) {
                alt57=1;
            }
            switch (alt57) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:63:54: comparacion2
                    {
                    pushFollow(FOLLOW_comparacion2_in_comparacion_for765);
                    comparacion2();

                    state._fsp--;


                    }
                    break;

            }


            match(input,SEPARADOR,FOLLOW_SEPARADOR_in_comparacion_for768); 

            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:63:78: ( comparacion3 )?
            int alt58=2;
            int LA58_0 = input.LA(1);

            if ( (LA58_0==IDENT||LA58_0==MAS||LA58_0==MENOS) ) {
                alt58=1;
            }
            switch (alt58) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:63:78: comparacion3
                    {
                    pushFollow(FOLLOW_comparacion3_in_comparacion_for770);
                    comparacion3();

                    state._fsp--;


                    }
                    break;

            }


            match(input,CPARENTESIS,FOLLOW_CPARENTESIS_in_comparacion_for773); 

            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "comparacion_for"



    // $ANTLR start "comparacion1"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:64:1: comparacion1 : ( TIPO )? IDENT IGUAL NUMERO ;
    public final void comparacion1() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:64:13: ( ( TIPO )? IDENT IGUAL NUMERO )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:64:15: ( TIPO )? IDENT IGUAL NUMERO
            {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:64:15: ( TIPO )?
            int alt59=2;
            int LA59_0 = input.LA(1);

            if ( (LA59_0==TIPO) ) {
                alt59=1;
            }
            switch (alt59) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:64:16: TIPO
                    {
                    match(input,TIPO,FOLLOW_TIPO_in_comparacion1780); 

                    }
                    break;

            }


            match(input,IDENT,FOLLOW_IDENT_in_comparacion1784); 

            match(input,IGUAL,FOLLOW_IGUAL_in_comparacion1786); 

            match(input,NUMERO,FOLLOW_NUMERO_in_comparacion1788); 

            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "comparacion1"



    // $ANTLR start "infor"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:65:1: infor : APARENTESIS operacion CPARENTESIS ;
    public final void infor() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:65:6: ( APARENTESIS operacion CPARENTESIS )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:65:8: APARENTESIS operacion CPARENTESIS
            {
            match(input,APARENTESIS,FOLLOW_APARENTESIS_in_infor794); 

            pushFollow(FOLLOW_operacion_in_infor796);
            operacion();

            state._fsp--;


            match(input,CPARENTESIS,FOLLOW_CPARENTESIS_in_infor798); 

            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "infor"



    // $ANTLR start "comparacion2"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:66:1: comparacion2 : ( infor | struct ) ( MAYOR ( IGUAL )? | MENOR ( IGUAL )? | IGUAL IGUAL ) ( NUMERO | IDENT ) ;
    public final void comparacion2() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:66:13: ( ( infor | struct ) ( MAYOR ( IGUAL )? | MENOR ( IGUAL )? | IGUAL IGUAL ) ( NUMERO | IDENT ) )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:66:15: ( infor | struct ) ( MAYOR ( IGUAL )? | MENOR ( IGUAL )? | IGUAL IGUAL ) ( NUMERO | IDENT )
            {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:66:15: ( infor | struct )
            int alt60=2;
            int LA60_0 = input.LA(1);

            if ( (LA60_0==APARENTESIS) ) {
                alt60=1;
            }
            else if ( (LA60_0==ASTERISCO||LA60_0==DOLARDOLAR||LA60_0==IDENT||LA60_0==VAR) ) {
                alt60=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 60, 0, input);

                throw nvae;

            }
            switch (alt60) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:66:16: infor
                    {
                    pushFollow(FOLLOW_infor_in_comparacion2805);
                    infor();

                    state._fsp--;


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:66:22: struct
                    {
                    pushFollow(FOLLOW_struct_in_comparacion2807);
                    struct();

                    state._fsp--;


                    }
                    break;

            }


            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:66:30: ( MAYOR ( IGUAL )? | MENOR ( IGUAL )? | IGUAL IGUAL )
            int alt63=3;
            switch ( input.LA(1) ) {
            case MAYOR:
                {
                alt63=1;
                }
                break;
            case MENOR:
                {
                alt63=2;
                }
                break;
            case IGUAL:
                {
                alt63=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 63, 0, input);

                throw nvae;

            }

            switch (alt63) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:66:31: MAYOR ( IGUAL )?
                    {
                    match(input,MAYOR,FOLLOW_MAYOR_in_comparacion2811); 

                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:66:37: ( IGUAL )?
                    int alt61=2;
                    int LA61_0 = input.LA(1);

                    if ( (LA61_0==IGUAL) ) {
                        alt61=1;
                    }
                    switch (alt61) {
                        case 1 :
                            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:66:37: IGUAL
                            {
                            match(input,IGUAL,FOLLOW_IGUAL_in_comparacion2813); 

                            }
                            break;

                    }


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:66:44: MENOR ( IGUAL )?
                    {
                    match(input,MENOR,FOLLOW_MENOR_in_comparacion2816); 

                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:66:50: ( IGUAL )?
                    int alt62=2;
                    int LA62_0 = input.LA(1);

                    if ( (LA62_0==IGUAL) ) {
                        alt62=1;
                    }
                    switch (alt62) {
                        case 1 :
                            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:66:50: IGUAL
                            {
                            match(input,IGUAL,FOLLOW_IGUAL_in_comparacion2818); 

                            }
                            break;

                    }


                    }
                    break;
                case 3 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:66:58: IGUAL IGUAL
                    {
                    match(input,IGUAL,FOLLOW_IGUAL_in_comparacion2822); 

                    match(input,IGUAL,FOLLOW_IGUAL_in_comparacion2824); 

                    }
                    break;

            }


            if ( input.LA(1)==IDENT||input.LA(1)==NUMERO ) {
                input.consume();
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "comparacion2"



    // $ANTLR start "comparacion3"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:67:1: comparacion3 : ( IDENT ( MAS MAS | MENOS MENOS ) | ( MAS MAS | MENOS MENOS ) IDENT ) ( COMA igualacion )? ;
    public final void comparacion3() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:67:13: ( ( IDENT ( MAS MAS | MENOS MENOS ) | ( MAS MAS | MENOS MENOS ) IDENT ) ( COMA igualacion )? )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:67:15: ( IDENT ( MAS MAS | MENOS MENOS ) | ( MAS MAS | MENOS MENOS ) IDENT ) ( COMA igualacion )?
            {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:67:15: ( IDENT ( MAS MAS | MENOS MENOS ) | ( MAS MAS | MENOS MENOS ) IDENT )
            int alt66=2;
            int LA66_0 = input.LA(1);

            if ( (LA66_0==IDENT) ) {
                alt66=1;
            }
            else if ( (LA66_0==MAS||LA66_0==MENOS) ) {
                alt66=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 66, 0, input);

                throw nvae;

            }
            switch (alt66) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:67:16: IDENT ( MAS MAS | MENOS MENOS )
                    {
                    match(input,IDENT,FOLLOW_IDENT_in_comparacion3838); 

                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:67:22: ( MAS MAS | MENOS MENOS )
                    int alt64=2;
                    int LA64_0 = input.LA(1);

                    if ( (LA64_0==MAS) ) {
                        alt64=1;
                    }
                    else if ( (LA64_0==MENOS) ) {
                        alt64=2;
                    }
                    else {
                        NoViableAltException nvae =
                            new NoViableAltException("", 64, 0, input);

                        throw nvae;

                    }
                    switch (alt64) {
                        case 1 :
                            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:67:23: MAS MAS
                            {
                            match(input,MAS,FOLLOW_MAS_in_comparacion3841); 

                            match(input,MAS,FOLLOW_MAS_in_comparacion3843); 

                            }
                            break;
                        case 2 :
                            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:67:32: MENOS MENOS
                            {
                            match(input,MENOS,FOLLOW_MENOS_in_comparacion3846); 

                            match(input,MENOS,FOLLOW_MENOS_in_comparacion3848); 

                            }
                            break;

                    }


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:67:47: ( MAS MAS | MENOS MENOS ) IDENT
                    {
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:67:47: ( MAS MAS | MENOS MENOS )
                    int alt65=2;
                    int LA65_0 = input.LA(1);

                    if ( (LA65_0==MAS) ) {
                        alt65=1;
                    }
                    else if ( (LA65_0==MENOS) ) {
                        alt65=2;
                    }
                    else {
                        NoViableAltException nvae =
                            new NoViableAltException("", 65, 0, input);

                        throw nvae;

                    }
                    switch (alt65) {
                        case 1 :
                            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:67:48: MAS MAS
                            {
                            match(input,MAS,FOLLOW_MAS_in_comparacion3854); 

                            match(input,MAS,FOLLOW_MAS_in_comparacion3856); 

                            }
                            break;
                        case 2 :
                            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:67:58: MENOS MENOS
                            {
                            match(input,MENOS,FOLLOW_MENOS_in_comparacion3860); 

                            match(input,MENOS,FOLLOW_MENOS_in_comparacion3862); 

                            }
                            break;

                    }


                    match(input,IDENT,FOLLOW_IDENT_in_comparacion3865); 

                    }
                    break;

            }


            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:67:78: ( COMA igualacion )?
            int alt67=2;
            int LA67_0 = input.LA(1);

            if ( (LA67_0==COMA) ) {
                alt67=1;
            }
            switch (alt67) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:67:79: COMA igualacion
                    {
                    match(input,COMA,FOLLOW_COMA_in_comparacion3869); 

                    pushFollow(FOLLOW_igualacion_in_comparacion3871);
                    igualacion();

                    state._fsp--;


                    }
                    break;

            }


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "comparacion3"



    // $ANTLR start "estructuracond"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:68:1: estructuracond : IF comparacion cuerpobucles ( ELSE cuerpobucles )? ;
    public final void estructuracond() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:68:15: ( IF comparacion cuerpobucles ( ELSE cuerpobucles )? )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:68:17: IF comparacion cuerpobucles ( ELSE cuerpobucles )?
            {
            match(input,IF,FOLLOW_IF_in_estructuracond879); 

            pushFollow(FOLLOW_comparacion_in_estructuracond881);
            comparacion();

            state._fsp--;


            pushFollow(FOLLOW_cuerpobucles_in_estructuracond883);
            cuerpobucles();

            state._fsp--;


            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:68:45: ( ELSE cuerpobucles )?
            int alt68=2;
            int LA68_0 = input.LA(1);

            if ( (LA68_0==ELSE) ) {
                alt68=1;
            }
            switch (alt68) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:68:46: ELSE cuerpobucles
                    {
                    match(input,ELSE,FOLLOW_ELSE_in_estructuracond886); 

                    pushFollow(FOLLOW_cuerpobucles_in_estructuracond888);
                    cuerpobucles();

                    state._fsp--;


                    }
                    break;

            }


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "estructuracond"



    // $ANTLR start "bucles"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:69:1: bucles : ( ( ( bucle | buclefor ) cuerpobucles ) | estructuracond ) ;
    public final void bucles() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:69:7: ( ( ( ( bucle | buclefor ) cuerpobucles ) | estructuracond ) )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:69:9: ( ( ( bucle | buclefor ) cuerpobucles ) | estructuracond )
            {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:69:9: ( ( ( bucle | buclefor ) cuerpobucles ) | estructuracond )
            int alt70=2;
            int LA70_0 = input.LA(1);

            if ( (LA70_0==FOR||LA70_0==WHILE) ) {
                alt70=1;
            }
            else if ( (LA70_0==IF) ) {
                alt70=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 70, 0, input);

                throw nvae;

            }
            switch (alt70) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:69:10: ( ( bucle | buclefor ) cuerpobucles )
                    {
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:69:10: ( ( bucle | buclefor ) cuerpobucles )
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:69:11: ( bucle | buclefor ) cuerpobucles
                    {
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:69:11: ( bucle | buclefor )
                    int alt69=2;
                    int LA69_0 = input.LA(1);

                    if ( (LA69_0==WHILE) ) {
                        alt69=1;
                    }
                    else if ( (LA69_0==FOR) ) {
                        alt69=2;
                    }
                    else {
                        NoViableAltException nvae =
                            new NoViableAltException("", 69, 0, input);

                        throw nvae;

                    }
                    switch (alt69) {
                        case 1 :
                            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:69:12: bucle
                            {
                            pushFollow(FOLLOW_bucle_in_bucles899);
                            bucle();

                            state._fsp--;


                            }
                            break;
                        case 2 :
                            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:69:18: buclefor
                            {
                            pushFollow(FOLLOW_buclefor_in_bucles901);
                            buclefor();

                            state._fsp--;


                            }
                            break;

                    }


                    pushFollow(FOLLOW_cuerpobucles_in_bucles904);
                    cuerpobucles();

                    state._fsp--;


                    }


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:69:44: estructuracond
                    {
                    pushFollow(FOLLOW_estructuracond_in_bucles909);
                    estructuracond();

                    state._fsp--;


                    }
                    break;

            }


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "bucles"



    // $ANTLR start "cuerpobucles"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:70:1: cuerpobucles : ( ALLAVE ( cuerpo )* CLLAVE | cuerpo ) ;
    public final void cuerpobucles() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:70:13: ( ( ALLAVE ( cuerpo )* CLLAVE | cuerpo ) )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:70:15: ( ALLAVE ( cuerpo )* CLLAVE | cuerpo )
            {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:70:15: ( ALLAVE ( cuerpo )* CLLAVE | cuerpo )
            int alt72=2;
            int LA72_0 = input.LA(1);

            if ( (LA72_0==ALLAVE) ) {
                alt72=1;
            }
            else if ( (LA72_0==ASTERISCO||LA72_0==BREAK||LA72_0==DOLARDOLAR||(LA72_0 >= FOR && LA72_0 <= IF)||LA72_0==RETURN||LA72_0==TIPO||LA72_0==VAR||LA72_0==WHILE) ) {
                alt72=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 72, 0, input);

                throw nvae;

            }
            switch (alt72) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:70:16: ALLAVE ( cuerpo )* CLLAVE
                    {
                    match(input,ALLAVE,FOLLOW_ALLAVE_in_cuerpobucles918); 

                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:70:23: ( cuerpo )*
                    loop71:
                    do {
                        int alt71=2;
                        int LA71_0 = input.LA(1);

                        if ( (LA71_0==ASTERISCO||LA71_0==BREAK||LA71_0==DOLARDOLAR||(LA71_0 >= FOR && LA71_0 <= IF)||LA71_0==RETURN||LA71_0==TIPO||LA71_0==VAR||LA71_0==WHILE) ) {
                            alt71=1;
                        }


                        switch (alt71) {
                    	case 1 :
                    	    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:70:23: cuerpo
                    	    {
                    	    pushFollow(FOLLOW_cuerpo_in_cuerpobucles920);
                    	    cuerpo();

                    	    state._fsp--;


                    	    }
                    	    break;

                    	default :
                    	    break loop71;
                        }
                    } while (true);


                    match(input,CLLAVE,FOLLOW_CLLAVE_in_cuerpobucles923); 

                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:70:39: cuerpo
                    {
                    pushFollow(FOLLOW_cuerpo_in_cuerpobucles926);
                    cuerpo();

                    state._fsp--;


                    }
                    break;

            }


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "cuerpobucles"



    // $ANTLR start "cuerpo"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:71:1: cuerpo : ( bucles | definicion | sentencia | retorno | BREAK SEPARADOR ) ;
    public final void cuerpo() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:71:7: ( ( bucles | definicion | sentencia | retorno | BREAK SEPARADOR ) )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:71:9: ( bucles | definicion | sentencia | retorno | BREAK SEPARADOR )
            {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:71:9: ( bucles | definicion | sentencia | retorno | BREAK SEPARADOR )
            int alt73=5;
            switch ( input.LA(1) ) {
            case FOR:
            case IF:
            case WHILE:
                {
                alt73=1;
                }
                break;
            case IDENT:
                {
                int LA73_2 = input.LA(2);

                if ( (LA73_2==ACORCHETE||LA73_2==APARENTESIS||LA73_2==COMA||LA73_2==IGUAL||LA73_2==PUNTO||LA73_2==SEPARADOR) ) {
                    alt73=3;
                }
                else if ( (LA73_2==ASTERISCO||LA73_2==DOLARDOLAR||LA73_2==IDENT||LA73_2==VAR) ) {
                    alt73=2;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 73, 2, input);

                    throw nvae;

                }
                }
                break;
            case ASTERISCO:
            case DOLARDOLAR:
            case VAR:
                {
                alt73=3;
                }
                break;
            case TIPO:
                {
                alt73=2;
                }
                break;
            case RETURN:
                {
                alt73=4;
                }
                break;
            case BREAK:
                {
                alt73=5;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 73, 0, input);

                throw nvae;

            }

            switch (alt73) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:71:10: bucles
                    {
                    pushFollow(FOLLOW_bucles_in_cuerpo934);
                    bucles();

                    state._fsp--;


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:71:17: definicion
                    {
                    pushFollow(FOLLOW_definicion_in_cuerpo936);
                    definicion();

                    state._fsp--;


                    }
                    break;
                case 3 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:71:28: sentencia
                    {
                    pushFollow(FOLLOW_sentencia_in_cuerpo938);
                    sentencia();

                    state._fsp--;


                    }
                    break;
                case 4 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:71:38: retorno
                    {
                    pushFollow(FOLLOW_retorno_in_cuerpo940);
                    retorno();

                    state._fsp--;


                    }
                    break;
                case 5 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:71:46: BREAK SEPARADOR
                    {
                    match(input,BREAK,FOLLOW_BREAK_in_cuerpo942); 

                    match(input,SEPARADOR,FOLLOW_SEPARADOR_in_cuerpo944); 

                    }
                    break;

            }


            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "cuerpo"



    // $ANTLR start "cond_aritmetico"
    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:73:1: cond_aritmetico : IDENT ( MAYOR ( IGUAL )? | MENOR ( IGUAL )? | IGUAL IGUAL ) NUMERO INTERROGANTE NUMERO DOSPUNTOS NUMERO ;
    public final void cond_aritmetico() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:73:16: ( IDENT ( MAYOR ( IGUAL )? | MENOR ( IGUAL )? | IGUAL IGUAL ) NUMERO INTERROGANTE NUMERO DOSPUNTOS NUMERO )
            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:73:18: IDENT ( MAYOR ( IGUAL )? | MENOR ( IGUAL )? | IGUAL IGUAL ) NUMERO INTERROGANTE NUMERO DOSPUNTOS NUMERO
            {
            match(input,IDENT,FOLLOW_IDENT_in_cond_aritmetico952); 

            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:73:24: ( MAYOR ( IGUAL )? | MENOR ( IGUAL )? | IGUAL IGUAL )
            int alt76=3;
            switch ( input.LA(1) ) {
            case MAYOR:
                {
                alt76=1;
                }
                break;
            case MENOR:
                {
                alt76=2;
                }
                break;
            case IGUAL:
                {
                alt76=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 76, 0, input);

                throw nvae;

            }

            switch (alt76) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:73:25: MAYOR ( IGUAL )?
                    {
                    match(input,MAYOR,FOLLOW_MAYOR_in_cond_aritmetico955); 

                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:73:31: ( IGUAL )?
                    int alt74=2;
                    int LA74_0 = input.LA(1);

                    if ( (LA74_0==IGUAL) ) {
                        alt74=1;
                    }
                    switch (alt74) {
                        case 1 :
                            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:73:31: IGUAL
                            {
                            match(input,IGUAL,FOLLOW_IGUAL_in_cond_aritmetico957); 

                            }
                            break;

                    }


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:73:38: MENOR ( IGUAL )?
                    {
                    match(input,MENOR,FOLLOW_MENOR_in_cond_aritmetico960); 

                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:73:44: ( IGUAL )?
                    int alt75=2;
                    int LA75_0 = input.LA(1);

                    if ( (LA75_0==IGUAL) ) {
                        alt75=1;
                    }
                    switch (alt75) {
                        case 1 :
                            // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:73:44: IGUAL
                            {
                            match(input,IGUAL,FOLLOW_IGUAL_in_cond_aritmetico962); 

                            }
                            break;

                    }


                    }
                    break;
                case 3 :
                    // C:\\Users\\Jose\\workspace\\prac7\\src\\main\\java\\PL\\prac7\\YACCParser.g:73:52: IGUAL IGUAL
                    {
                    match(input,IGUAL,FOLLOW_IGUAL_in_cond_aritmetico966); 

                    match(input,IGUAL,FOLLOW_IGUAL_in_cond_aritmetico968); 

                    }
                    break;

            }


            match(input,NUMERO,FOLLOW_NUMERO_in_cond_aritmetico971); 

            match(input,INTERROGANTE,FOLLOW_INTERROGANTE_in_cond_aritmetico973); 

            match(input,NUMERO,FOLLOW_NUMERO_in_cond_aritmetico975); 

            match(input,DOSPUNTOS,FOLLOW_DOSPUNTOS_in_cond_aritmetico977); 

            match(input,NUMERO,FOLLOW_NUMERO_in_cond_aritmetico979); 

            }

        }
        catch (RecognitionException e) {
          throw e;}
         
        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "cond_aritmetico"

    // Delegated rules


    protected DFA15 dfa15 = new DFA15(this);
    protected DFA32 dfa32 = new DFA32(this);
    static final String DFA15_eotS =
        "\20\uffff";
    static final String DFA15_eofS =
        "\20\uffff";
    static final String DFA15_minS =
        "\1\6\1\uffff\1\10\1\43\1\27\1\uffff\1\4\3\uffff\1\11\1\4\1\5\1\uffff"+
        "\1\11\1\4";
    static final String DFA15_maxS =
        "\1\75\1\uffff\2\53\1\46\1\uffff\1\10\3\uffff\1\75\1\66\1\72\1\uffff"+
        "\1\74\1\66";
    static final String DFA15_acceptS =
        "\1\uffff\1\6\3\uffff\1\3\1\uffff\1\1\1\2\1\5\3\uffff\1\4\2\uffff";
    static final String DFA15_specialS =
        "\20\uffff}>";
    static final String[] DFA15_transitionS = {
            "\1\4\30\uffff\2\1\2\uffff\1\2\7\uffff\1\1\16\uffff\1\3\1\5\1"+
            "\uffff\1\1",
            "",
            "\1\1\32\uffff\1\6\7\uffff\1\1",
            "\1\6\7\uffff\1\1",
            "\1\7\16\uffff\1\10",
            "",
            "\1\11\3\uffff\1\12",
            "",
            "",
            "",
            "\1\15\3\uffff\2\15\3\uffff\1\15\3\uffff\1\14\3\uffff\1\15\10"+
            "\uffff\1\13\13\uffff\1\15\2\uffff\1\15\7\uffff\1\1\1\uffff\1"+
            "\15\1\1",
            "\1\15\3\uffff\3\15\7\uffff\1\16\3\uffff\1\14\25\uffff\1\15"+
            "\2\uffff\1\15\6\uffff\1\15",
            "\1\1\14\uffff\1\15\20\uffff\1\1\24\uffff\1\15\1\uffff\1\1",
            "",
            "\1\15\3\uffff\2\15\13\uffff\1\15\10\uffff\1\17\13\uffff\1\15"+
            "\2\uffff\1\15\7\uffff\1\1\1\uffff\1\15",
            "\1\15\3\uffff\3\15\7\uffff\1\16\3\uffff\1\14\25\uffff\1\15"+
            "\2\uffff\1\15\6\uffff\1\15"
    };

    static final short[] DFA15_eot = DFA.unpackEncodedString(DFA15_eotS);
    static final short[] DFA15_eof = DFA.unpackEncodedString(DFA15_eofS);
    static final char[] DFA15_min = DFA.unpackEncodedStringToUnsignedChars(DFA15_minS);
    static final char[] DFA15_max = DFA.unpackEncodedStringToUnsignedChars(DFA15_maxS);
    static final short[] DFA15_accept = DFA.unpackEncodedString(DFA15_acceptS);
    static final short[] DFA15_special = DFA.unpackEncodedString(DFA15_specialS);
    static final short[][] DFA15_transition;

    static {
        int numStates = DFA15_transitionS.length;
        DFA15_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA15_transition[i] = DFA.unpackEncodedString(DFA15_transitionS[i]);
        }
    }

    class DFA15 extends DFA {

        public DFA15(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 15;
            this.eot = DFA15_eot;
            this.eof = DFA15_eof;
            this.min = DFA15_min;
            this.max = DFA15_max;
            this.accept = DFA15_accept;
            this.special = DFA15_special;
            this.transition = DFA15_transition;
        }
        public String getDescription() {
            return "()+ loopback of 29:15: ( define | include | typedefs | declarfunc | array )+";
        }
    }
    static final String DFA32_eotS =
        "\13\uffff";
    static final String DFA32_eofS =
        "\13\uffff";
    static final String DFA32_minS =
        "\1\6\1\uffff\1\10\1\uffff\1\43\1\4\1\11\1\4\1\5\1\11\1\4";
    static final String DFA32_maxS =
        "\1\75\1\uffff\1\53\1\uffff\1\53\1\10\1\75\1\66\1\72\1\74\1\66";
    static final String DFA32_acceptS =
        "\1\uffff\1\1\1\uffff\1\2\7\uffff";
    static final String DFA32_specialS =
        "\13\uffff}>";
    static final String[] DFA32_transitionS = {
            "\1\1\30\uffff\1\3\3\uffff\1\2\7\uffff\1\3\16\uffff\1\4\1\1\1"+
            "\uffff\1\3",
            "",
            "\1\3\32\uffff\1\5\7\uffff\1\3",
            "",
            "\1\5\7\uffff\1\3",
            "\1\1\3\uffff\1\6",
            "\1\1\3\uffff\2\1\3\uffff\1\1\3\uffff\1\10\3\uffff\1\1\10\uffff"+
            "\1\7\13\uffff\1\1\2\uffff\1\1\7\uffff\1\3\1\uffff\1\1\1\3",
            "\1\1\3\uffff\3\1\7\uffff\1\11\3\uffff\1\10\25\uffff\1\1\2\uffff"+
            "\1\1\6\uffff\1\1",
            "\1\3\14\uffff\1\1\20\uffff\1\3\24\uffff\1\1\1\uffff\1\3",
            "\1\1\3\uffff\2\1\13\uffff\1\1\10\uffff\1\12\13\uffff\1\1\2"+
            "\uffff\1\1\7\uffff\1\3\1\uffff\1\1",
            "\1\1\3\uffff\3\1\7\uffff\1\11\3\uffff\1\10\25\uffff\1\1\2\uffff"+
            "\1\1\6\uffff\1\1"
    };

    static final short[] DFA32_eot = DFA.unpackEncodedString(DFA32_eotS);
    static final short[] DFA32_eof = DFA.unpackEncodedString(DFA32_eofS);
    static final char[] DFA32_min = DFA.unpackEncodedStringToUnsignedChars(DFA32_minS);
    static final char[] DFA32_max = DFA.unpackEncodedStringToUnsignedChars(DFA32_maxS);
    static final short[] DFA32_accept = DFA.unpackEncodedString(DFA32_acceptS);
    static final short[] DFA32_special = DFA.unpackEncodedString(DFA32_specialS);
    static final short[][] DFA32_transition;

    static {
        int numStates = DFA32_transitionS.length;
        DFA32_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA32_transition[i] = DFA.unpackEncodedString(DFA32_transitionS[i]);
        }
    }

    class DFA32 extends DFA {

        public DFA32(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 32;
            this.eot = DFA32_eot;
            this.eof = DFA32_eof;
            this.min = DFA32_min;
            this.max = DFA32_max;
            this.accept = DFA32_accept;
            this.special = DFA32_special;
            this.transition = DFA32_transition;
        }
        public String getDescription() {
            return "48:9: ( declaracionc )?";
        }
    }
 

    public static final BitSet FOLLOW_definiciones_in_entrada47 = new BitSet(new long[]{0x8000000000000000L});
    public static final BitSet FOLLOW_expresiones_in_entrada49 = new BitSet(new long[]{0x2C00080880000040L});
    public static final BitSet FOLLOW_partec_in_entrada51 = new BitSet(new long[]{0x0000000000000000L});
    public static final BitSet FOLLOW_EOF_in_entrada54 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_identificador61 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_ACORCHETE_in_identificador63 = new BitSet(new long[]{0x100480080400E200L});
    public static final BitSet FOLLOW_operacion_in_identificador66 = new BitSet(new long[]{0x0000000000008000L});
    public static final BitSet FOLLOW_CCORCHETE_in_identificador70 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ASTERISCO_in_struct79 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_identificador_in_struct82 = new BitSet(new long[]{0x0040000000000002L});
    public static final BitSet FOLLOW_VAR_in_struct84 = new BitSet(new long[]{0x0040000000000002L});
    public static final BitSet FOLLOW_DOLARDOLAR_in_struct86 = new BitSet(new long[]{0x0040000000000002L});
    public static final BitSet FOLLOW_llamada_funcion_in_struct88 = new BitSet(new long[]{0x0040000000000002L});
    public static final BitSet FOLLOW_PUNTO_in_struct92 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_IDENT_in_struct94 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_struct_in_subsentencia103 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NUMERO_in_subsentencia106 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CADENA_in_subsentencia110 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CARACTER_in_subsentencia114 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_MENOS_in_operacion121 = new BitSet(new long[]{0x1004000804006200L});
    public static final BitSet FOLLOW_subsentencia_in_operacion124 = new BitSet(new long[]{0x0000900000000602L});
    public static final BitSet FOLLOW_set_in_operacion127 = new BitSet(new long[]{0x1004800804006200L});
    public static final BitSet FOLLOW_MENOS_in_operacion137 = new BitSet(new long[]{0x1004000804006200L});
    public static final BitSet FOLLOW_subsentencia_in_operacion140 = new BitSet(new long[]{0x0000900000000602L});
    public static final BitSet FOLLOW_struct_in_igualacion148 = new BitSet(new long[]{0x0000002000000002L});
    public static final BitSet FOLLOW_IGUAL_in_igualacion151 = new BitSet(new long[]{0x1004800804006200L});
    public static final BitSet FOLLOW_operacion_in_igualacion153 = new BitSet(new long[]{0x0000002000000002L});
    public static final BitSet FOLLOW_igualacion_in_sentencia161 = new BitSet(new long[]{0x0100000000040000L});
    public static final BitSet FOLLOW_COMA_in_sentencia164 = new BitSet(new long[]{0x1000000804000200L});
    public static final BitSet FOLLOW_igualacion_in_sentencia166 = new BitSet(new long[]{0x0100000000040000L});
    public static final BitSet FOLLOW_SEPARADOR_in_sentencia170 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_definicion176 = new BitSet(new long[]{0x1000000804000200L});
    public static final BitSet FOLLOW_igualacion_in_definicion182 = new BitSet(new long[]{0x0100000000040000L});
    public static final BitSet FOLLOW_COMA_in_definicion185 = new BitSet(new long[]{0x1000000804000200L});
    public static final BitSet FOLLOW_igualacion_in_definicion187 = new BitSet(new long[]{0x0100000000040000L});
    public static final BitSet FOLLOW_SEPARADOR_in_definicion191 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_INIDEFINICIONES_in_definiciones200 = new BitSet(new long[]{0x0C00000800000040L});
    public static final BitSet FOLLOW_declaracionc_in_definiciones202 = new BitSet(new long[]{0x0000000100000000L});
    public static final BitSet FOLLOW_FINDEFINICIONES_in_definiciones204 = new BitSet(new long[]{0x0020000000000002L});
    public static final BitSet FOLLOW_definiciontoken_in_definiciones207 = new BitSet(new long[]{0x0020000000000002L});
    public static final BitSet FOLLOW_define_in_declaracionc217 = new BitSet(new long[]{0x0C00000800000042L});
    public static final BitSet FOLLOW_include_in_declaracionc220 = new BitSet(new long[]{0x0C00000800000042L});
    public static final BitSet FOLLOW_typedefs_in_declaracionc222 = new BitSet(new long[]{0x0C00000800000042L});
    public static final BitSet FOLLOW_declarfunc_in_declaracionc224 = new BitSet(new long[]{0x0C00000800000042L});
    public static final BitSet FOLLOW_array_in_declaracionc226 = new BitSet(new long[]{0x0C00000800000042L});
    public static final BitSet FOLLOW_set_in_array234 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_IDENT_in_array240 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_ACORCHETE_in_array242 = new BitSet(new long[]{0x0004000000000000L});
    public static final BitSet FOLLOW_NUMERO_in_array244 = new BitSet(new long[]{0x0000000000008000L});
    public static final BitSet FOLLOW_CCORCHETE_in_array246 = new BitSet(new long[]{0x0100000000000000L});
    public static final BitSet FOLLOW_SEPARADOR_in_array248 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_declarfunc254 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_llamada_funcion_in_declarfunc260 = new BitSet(new long[]{0x0100000000040000L});
    public static final BitSet FOLLOW_COMA_in_declarfunc263 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_llamada_funcion_in_declarfunc265 = new BitSet(new long[]{0x0100000000040000L});
    public static final BitSet FOLLOW_SEPARADOR_in_declarfunc269 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_TYPEDEF_in_typedefs275 = new BitSet(new long[]{0x0200000000000000L});
    public static final BitSet FOLLOW_STRUCT_in_typedefs277 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_IDENT_in_typedefs279 = new BitSet(new long[]{0x0000000000000020L});
    public static final BitSet FOLLOW_ALLAVE_in_typedefs281 = new BitSet(new long[]{0x0400000800000000L});
    public static final BitSet FOLLOW_varindefs_in_typedefs284 = new BitSet(new long[]{0x0400000800020000L});
    public static final BitSet FOLLOW_CLLAVE_in_typedefs288 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_IDENT_in_typedefs290 = new BitSet(new long[]{0x0100000000000000L});
    public static final BitSet FOLLOW_SEPARADOR_in_typedefs292 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_varindefs298 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_IDENT_in_varindefs304 = new BitSet(new long[]{0x0100000000040000L});
    public static final BitSet FOLLOW_COMA_in_varindefs307 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_IDENT_in_varindefs309 = new BitSet(new long[]{0x0100000000040000L});
    public static final BitSet FOLLOW_SEPARADOR_in_varindefs313 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PORCENTAJE_in_definiciontoken319 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_IDENT_in_definiciontoken321 = new BitSet(new long[]{0x0000400800004020L});
    public static final BitSet FOLLOW_IDENT_in_definiciontoken324 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CARACTER_in_definiciontoken327 = new BitSet(new long[]{0x0000000000004002L});
    public static final BitSet FOLLOW_conjunto_in_definiciontoken331 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_MENOR_in_definiciontoken334 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_IDENT_in_definiciontoken336 = new BitSet(new long[]{0x0000200000000000L});
    public static final BitSet FOLLOW_MAYOR_in_definiciontoken338 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_IDENT_in_definiciontoken340 = new BitSet(new long[]{0x0000000800000002L});
    public static final BitSet FOLLOW_PORCENTAJE_in_typetoken349 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000003L});
    public static final BitSet FOLLOW_set_in_typetoken351 = new BitSet(new long[]{0x0000400000000000L});
    public static final BitSet FOLLOW_MENOR_in_typetoken357 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_IDENT_in_typetoken359 = new BitSet(new long[]{0x0000200000000000L});
    public static final BitSet FOLLOW_MAYOR_in_typetoken361 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_IDENT_in_typetoken363 = new BitSet(new long[]{0x0000000800000002L});
    public static final BitSet FOLLOW_ALLAVE_in_conjunto370 = new BitSet(new long[]{0x0400000800000000L});
    public static final BitSet FOLLOW_varindefs_in_conjunto373 = new BitSet(new long[]{0x0400000800020000L});
    public static final BitSet FOLLOW_CLLAVE_in_conjunto377 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ALMOHADILLA_in_define383 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_DEFINE_in_define385 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_IDENT_in_define387 = new BitSet(new long[]{0x0404000000000000L});
    public static final BitSet FOLLOW_set_in_define389 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ALMOHADILLA_in_include399 = new BitSet(new long[]{0x0000004000000000L});
    public static final BitSet FOLLOW_INCLUDE_in_include401 = new BitSet(new long[]{0x0000400000000000L});
    public static final BitSet FOLLOW_MENOR_in_include403 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_IDENT_in_include405 = new BitSet(new long[]{0x0040000000000000L});
    public static final BitSet FOLLOW_PUNTO_in_include407 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_IDENT_in_include409 = new BitSet(new long[]{0x0000200000000000L});
    public static final BitSet FOLLOW_MAYOR_in_include411 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ZONAREGLA_in_expresiones419 = new BitSet(new long[]{0x8000000800000000L});
    public static final BitSet FOLLOW_reglas_in_expresiones421 = new BitSet(new long[]{0x8000000800000000L});
    public static final BitSet FOLLOW_ZONAREGLA_in_expresiones424 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_reglas430 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_DOSPUNTOS_in_reglas432 = new BitSet(new long[]{0x0130000800004000L});
    public static final BitSet FOLLOW_patron_in_reglas434 = new BitSet(new long[]{0x0110000000000000L});
    public static final BitSet FOLLOW_ORYACC_in_reglas438 = new BitSet(new long[]{0x0020000800004000L});
    public static final BitSet FOLLOW_patron_in_reglas440 = new BitSet(new long[]{0x0110000000000000L});
    public static final BitSet FOLLOW_SEPARADOR_in_reglas444 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CARACTER_in_patron451 = new BitSet(new long[]{0x0020000800004022L});
    public static final BitSet FOLLOW_PORCENTAJE_in_patron454 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_IDENT_in_patron457 = new BitSet(new long[]{0x0020000800004022L});
    public static final BitSet FOLLOW_def_cuerpo_in_patron461 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_llamada_funcion468 = new BitSet(new long[]{0x0000000000000100L});
    public static final BitSet FOLLOW_APARENTESIS_in_llamada_funcion470 = new BitSet(new long[]{0x1004800804446200L});
    public static final BitSet FOLLOW_operacion_in_llamada_funcion473 = new BitSet(new long[]{0x0000000000440000L});
    public static final BitSet FOLLOW_segundo_param_in_llamada_funcion478 = new BitSet(new long[]{0x0000000000440000L});
    public static final BitSet FOLLOW_CPARENTESIS_in_llamada_funcion482 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_COMA_in_segundo_param488 = new BitSet(new long[]{0x1004800804006200L});
    public static final BitSet FOLLOW_operacion_in_segundo_param491 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_declaracionc_in_partec501 = new BitSet(new long[]{0x2400080880000000L});
    public static final BitSet FOLLOW_declaracion_in_partec504 = new BitSet(new long[]{0x2400080880000000L});
    public static final BitSet FOLLOW_funcion_in_partec507 = new BitSet(new long[]{0x2400080800000002L});
    public static final BitSet FOLLOW_EXTERN_in_declaracion514 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_IDENT_in_declaracion516 = new BitSet(new long[]{0x0000000800000200L});
    public static final BitSet FOLLOW_ASTERISCO_in_declaracion518 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_IDENT_in_declaracion521 = new BitSet(new long[]{0x0100000000000000L});
    public static final BitSet FOLLOW_SEPARADOR_in_declaracion523 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_def_funcion_in_funcion530 = new BitSet(new long[]{0x0000000000000020L});
    public static final BitSet FOLLOW_def_cuerpo_in_funcion532 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_def_funcion547 = new BitSet(new long[]{0x0000000000000100L});
    public static final BitSet FOLLOW_APARENTESIS_in_def_funcion553 = new BitSet(new long[]{0x2400000800400000L});
    public static final BitSet FOLLOW_VOID_in_def_funcion556 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_llamada_variable_in_def_funcion562 = new BitSet(new long[]{0x0000000000440000L});
    public static final BitSet FOLLOW_IDENT_in_def_funcion565 = new BitSet(new long[]{0x0000000000440000L});
    public static final BitSet FOLLOW_COMA_in_def_funcion569 = new BitSet(new long[]{0x0400000800000000L});
    public static final BitSet FOLLOW_llamada_variable_in_def_funcion572 = new BitSet(new long[]{0x0000000000440000L});
    public static final BitSet FOLLOW_IDENT_in_def_funcion576 = new BitSet(new long[]{0x0000000000440000L});
    public static final BitSet FOLLOW_CPARENTESIS_in_def_funcion584 = new BitSet(new long[]{0x0400000800000002L});
    public static final BitSet FOLLOW_definicion_in_def_funcion586 = new BitSet(new long[]{0x0400000800000002L});
    public static final BitSet FOLLOW_TIPO_in_llamada_variable593 = new BitSet(new long[]{0x0000000800000200L});
    public static final BitSet FOLLOW_ASTERISCO_in_llamada_variable596 = new BitSet(new long[]{0x0000000800000200L});
    public static final BitSet FOLLOW_IDENT_in_llamada_variable600 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_ACORCHETE_in_llamada_variable603 = new BitSet(new long[]{0x0000000000008000L});
    public static final BitSet FOLLOW_CCORCHETE_in_llamada_variable605 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ALLAVE_in_def_cuerpo614 = new BitSet(new long[]{0x5480001C04020200L});
    public static final BitSet FOLLOW_sentencia_in_def_cuerpo617 = new BitSet(new long[]{0x5480001C04020200L});
    public static final BitSet FOLLOW_definicion_in_def_cuerpo619 = new BitSet(new long[]{0x5480001C04020200L});
    public static final BitSet FOLLOW_retorno_in_def_cuerpo621 = new BitSet(new long[]{0x5480001C04020200L});
    public static final BitSet FOLLOW_bucles_in_def_cuerpo623 = new BitSet(new long[]{0x5480001C04020200L});
    public static final BitSet FOLLOW_CLLAVE_in_def_cuerpo627 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_RETURN_in_retorno633 = new BitSet(new long[]{0x1004000804006300L});
    public static final BitSet FOLLOW_APARENTESIS_in_retorno636 = new BitSet(new long[]{0x1004000804006200L});
    public static final BitSet FOLLOW_subsentencia_in_retorno638 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_CPARENTESIS_in_retorno640 = new BitSet(new long[]{0x0100000000000000L});
    public static final BitSet FOLLOW_subsentencia_in_retorno644 = new BitSet(new long[]{0x0100000000000000L});
    public static final BitSet FOLLOW_SEPARADOR_in_retorno647 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_APARENTESIS_in_comparacion653 = new BitSet(new long[]{0x1005800804006300L});
    public static final BitSet FOLLOW_reglascond_in_comparacion655 = new BitSet(new long[]{0x0008000000400080L});
    public static final BitSet FOLLOW_set_in_comparacion658 = new BitSet(new long[]{0x1005800804006300L});
    public static final BitSet FOLLOW_reglascond_in_comparacion666 = new BitSet(new long[]{0x0008000000400080L});
    public static final BitSet FOLLOW_CPARENTESIS_in_comparacion670 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_APARENTESIS_in_igualarencond676 = new BitSet(new long[]{0x1004800804006200L});
    public static final BitSet FOLLOW_operacion_in_igualarencond678 = new BitSet(new long[]{0x0000002000400000L});
    public static final BitSet FOLLOW_IGUAL_in_igualarencond681 = new BitSet(new long[]{0x1004800804006200L});
    public static final BitSet FOLLOW_operacion_in_igualarencond683 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_CPARENTESIS_in_igualarencond687 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_operacion_in_igualarencond690 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NOT_in_reglascond695 = new BitSet(new long[]{0x1004800804006300L});
    public static final BitSet FOLLOW_igualarencond_in_reglascond700 = new BitSet(new long[]{0x0000602000000002L});
    public static final BitSet FOLLOW_MAYOR_in_reglascond704 = new BitSet(new long[]{0x1004802804006300L});
    public static final BitSet FOLLOW_IGUAL_in_reglascond706 = new BitSet(new long[]{0x1004800804006300L});
    public static final BitSet FOLLOW_MENOR_in_reglascond709 = new BitSet(new long[]{0x1004802804006300L});
    public static final BitSet FOLLOW_IGUAL_in_reglascond711 = new BitSet(new long[]{0x1004800804006300L});
    public static final BitSet FOLLOW_IGUAL_in_reglascond715 = new BitSet(new long[]{0x0000002000000000L});
    public static final BitSet FOLLOW_IGUAL_in_reglascond717 = new BitSet(new long[]{0x1004800804006300L});
    public static final BitSet FOLLOW_igualarencond_in_reglascond720 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_cond_aritmetico_in_reglascond726 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_reglascond729 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_MAS_in_reglascond731 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_MAS_in_reglascond733 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_WHILE_in_bucle740 = new BitSet(new long[]{0x0000000000000100L});
    public static final BitSet FOLLOW_comparacion_in_bucle742 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FOR_in_buclefor750 = new BitSet(new long[]{0x0000000000000100L});
    public static final BitSet FOLLOW_comparacion_for_in_buclefor752 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_APARENTESIS_in_comparacion_for758 = new BitSet(new long[]{0x0500000800000000L});
    public static final BitSet FOLLOW_comparacion1_in_comparacion_for760 = new BitSet(new long[]{0x0100000000000000L});
    public static final BitSet FOLLOW_SEPARADOR_in_comparacion_for763 = new BitSet(new long[]{0x1100000804000300L});
    public static final BitSet FOLLOW_comparacion2_in_comparacion_for765 = new BitSet(new long[]{0x0100000000000000L});
    public static final BitSet FOLLOW_SEPARADOR_in_comparacion_for768 = new BitSet(new long[]{0x0000900800400000L});
    public static final BitSet FOLLOW_comparacion3_in_comparacion_for770 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_CPARENTESIS_in_comparacion_for773 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_TIPO_in_comparacion1780 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_IDENT_in_comparacion1784 = new BitSet(new long[]{0x0000002000000000L});
    public static final BitSet FOLLOW_IGUAL_in_comparacion1786 = new BitSet(new long[]{0x0004000000000000L});
    public static final BitSet FOLLOW_NUMERO_in_comparacion1788 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_APARENTESIS_in_infor794 = new BitSet(new long[]{0x1004800804006200L});
    public static final BitSet FOLLOW_operacion_in_infor796 = new BitSet(new long[]{0x0000000000400000L});
    public static final BitSet FOLLOW_CPARENTESIS_in_infor798 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_infor_in_comparacion2805 = new BitSet(new long[]{0x0000602000000000L});
    public static final BitSet FOLLOW_struct_in_comparacion2807 = new BitSet(new long[]{0x0000602000000000L});
    public static final BitSet FOLLOW_MAYOR_in_comparacion2811 = new BitSet(new long[]{0x0004002800000000L});
    public static final BitSet FOLLOW_IGUAL_in_comparacion2813 = new BitSet(new long[]{0x0004000800000000L});
    public static final BitSet FOLLOW_MENOR_in_comparacion2816 = new BitSet(new long[]{0x0004002800000000L});
    public static final BitSet FOLLOW_IGUAL_in_comparacion2818 = new BitSet(new long[]{0x0004000800000000L});
    public static final BitSet FOLLOW_IGUAL_in_comparacion2822 = new BitSet(new long[]{0x0000002000000000L});
    public static final BitSet FOLLOW_IGUAL_in_comparacion2824 = new BitSet(new long[]{0x0004000800000000L});
    public static final BitSet FOLLOW_set_in_comparacion2827 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_comparacion3838 = new BitSet(new long[]{0x0000900000000000L});
    public static final BitSet FOLLOW_MAS_in_comparacion3841 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_MAS_in_comparacion3843 = new BitSet(new long[]{0x0000000000040002L});
    public static final BitSet FOLLOW_MENOS_in_comparacion3846 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_MENOS_in_comparacion3848 = new BitSet(new long[]{0x0000000000040002L});
    public static final BitSet FOLLOW_MAS_in_comparacion3854 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_MAS_in_comparacion3856 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_MENOS_in_comparacion3860 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_MENOS_in_comparacion3862 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_IDENT_in_comparacion3865 = new BitSet(new long[]{0x0000000000040002L});
    public static final BitSet FOLLOW_COMA_in_comparacion3869 = new BitSet(new long[]{0x1000000804000200L});
    public static final BitSet FOLLOW_igualacion_in_comparacion3871 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IF_in_estructuracond879 = new BitSet(new long[]{0x0000000000000100L});
    public static final BitSet FOLLOW_comparacion_in_estructuracond881 = new BitSet(new long[]{0x5480001C04001220L});
    public static final BitSet FOLLOW_cuerpobucles_in_estructuracond883 = new BitSet(new long[]{0x0000000020000002L});
    public static final BitSet FOLLOW_ELSE_in_estructuracond886 = new BitSet(new long[]{0x5480001C04001220L});
    public static final BitSet FOLLOW_cuerpobucles_in_estructuracond888 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_bucle_in_bucles899 = new BitSet(new long[]{0x5480001C04001220L});
    public static final BitSet FOLLOW_buclefor_in_bucles901 = new BitSet(new long[]{0x5480001C04001220L});
    public static final BitSet FOLLOW_cuerpobucles_in_bucles904 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_estructuracond_in_bucles909 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ALLAVE_in_cuerpobucles918 = new BitSet(new long[]{0x5480001C04021200L});
    public static final BitSet FOLLOW_cuerpo_in_cuerpobucles920 = new BitSet(new long[]{0x5480001C04021200L});
    public static final BitSet FOLLOW_CLLAVE_in_cuerpobucles923 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_cuerpo_in_cuerpobucles926 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_bucles_in_cuerpo934 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_definicion_in_cuerpo936 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_sentencia_in_cuerpo938 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_retorno_in_cuerpo940 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_BREAK_in_cuerpo942 = new BitSet(new long[]{0x0100000000000000L});
    public static final BitSet FOLLOW_SEPARADOR_in_cuerpo944 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_cond_aritmetico952 = new BitSet(new long[]{0x0000602000000000L});
    public static final BitSet FOLLOW_MAYOR_in_cond_aritmetico955 = new BitSet(new long[]{0x0004002000000000L});
    public static final BitSet FOLLOW_IGUAL_in_cond_aritmetico957 = new BitSet(new long[]{0x0004000000000000L});
    public static final BitSet FOLLOW_MENOR_in_cond_aritmetico960 = new BitSet(new long[]{0x0004002000000000L});
    public static final BitSet FOLLOW_IGUAL_in_cond_aritmetico962 = new BitSet(new long[]{0x0004000000000000L});
    public static final BitSet FOLLOW_IGUAL_in_cond_aritmetico966 = new BitSet(new long[]{0x0000002000000000L});
    public static final BitSet FOLLOW_IGUAL_in_cond_aritmetico968 = new BitSet(new long[]{0x0004000000000000L});
    public static final BitSet FOLLOW_NUMERO_in_cond_aritmetico971 = new BitSet(new long[]{0x0000020000000000L});
    public static final BitSet FOLLOW_INTERROGANTE_in_cond_aritmetico973 = new BitSet(new long[]{0x0004000000000000L});
    public static final BitSet FOLLOW_NUMERO_in_cond_aritmetico975 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_DOSPUNTOS_in_cond_aritmetico977 = new BitSet(new long[]{0x0004000000000000L});
    public static final BitSet FOLLOW_NUMERO_in_cond_aritmetico979 = new BitSet(new long[]{0x0000000000000002L});

}